怎么制作一个属于自己的网站,wordpress 博客 简书,鱼台网站建设,android studio下载安装Executors 在Java 5之后#xff0c;并发编程引入了一堆新的启动、调度和管理线程的API。Executor框架便是Java 5中引入的#xff0c;其内部使用了线程池机制#xff0c;它在java.util.cocurrent 包下#xff0c;通过该框架来控制线程的启动、执行和关闭#xff0c;可以简化…Executors 在Java 5之后并发编程引入了一堆新的启动、调度和管理线程的API。Executor框架便是Java 5中引入的其内部使用了线程池机制它在java.util.cocurrent 包下通过该框架来控制线程的启动、执行和关闭可以简化并发编程的操作。因此在Java 5之后通过Executor来启动线程比使用Thread的start方法更好除了更易管理效率更好用线程池实现节约开销外还有关键的一点有助于避免this逃逸问题——如果我们在构造器中启动一个线程因为另一个任务可能会在构造器结束之前开始执行此时可能会访问到初始化了一半的对象用Executor在构造器中。 Eexecutor作为灵活且强大的异步执行框架其支持多种不同类型的任务执行策略提供了一种标准的方法将任务的提交过程和执行过程解耦开发基于生产者-消费者模式其提交任务的线程相当于生产者执行任务的线程相当于消费者并用Runnable来表示任务Executor的实现还提供了对生命周期的支持以及统计信息收集应用程序管理机制和性能监视等机制。 一、Executor的UML图常用的几个接口和子类 Executor框架包括线程池ExecutorExecutorsExecutorServiceCompletionServiceFutureCallable等。 二、Executor和ExecutorService
Executor一个接口其定义了一个接收Runnable对象的方法executor其方法签名为executor(Runnable command),该方法接收一个Runable实例它用来执行一个任务任务即一个实现了Runnable接口的类一般来说Runnable任务开辟在新线程中的使用方法为new Thread(new RunnableTask())).start()但在Executor中可以使用Executor而不用显示地创建线程executor.execute(new RunnableTask()); // 异步执行
ExecutorService是一个比Executor使用更广泛的子类接口其提供了生命周期管理的方法返回 Future 对象以及可跟踪一个或多个异步任务执行状况返回Future的方法可以调用ExecutorService的shutdown方法来平滑地关闭 ExecutorService调用该方法后将导致ExecutorService停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类一类是已经在执行的另一类是还没有开始执行的)当所有已经提交的任务执行完毕后将会关闭ExecutorService。因此我们一般用该接口来实现和管理多线程。
通过 ExecutorService.submit() 方法返回的 Future 对象可以调用isDone方法查询Future是否已经完成。当任务完成时它具有一个结果你可以调用get()方法来获取该结果。你也可以不用isDone进行检查就直接调用get()获取结果在这种情况下get()将阻塞直至结果准备就绪还可以取消任务的执行。Future 提供了 cancel() 方法用来取消执行 pending 中的任务。ExecutorService 部分代码如下
public interface ExecutorService extends Executor {void shutdown();T FutureT submit(CallableT task);T FutureT submit(Runnable task, T result);T ListFutureT invokeAll(Collection? extends CallableT tasks, long timeout, TimeUnit unit) throws InterruptedException;
}三、Executors类 主要用于提供线程池相关的操作
Executors类提供了一系列工厂方法用于创建线程池返回的线程池都实现了ExecutorService接口。
1、public static ExecutorService newFiexedThreadPool(int Threads) 创建固定数目线程的线程池。
2、public static ExecutorService newCachedThreadPool()创建一个可缓存的线程池调用execute 将重用以前构造的线程如果线程可用。如果没有可用的线程则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
3、public static ExecutorService newSingleThreadExecutor()创建一个单线程化的Executor。
4、public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创建一个支持定时及周期性的任务执行的线程池多数情况下可用来替代Timer类。 newCachedThreadPool() -缓存型池子先查看池中有没有以前建立的线程如果有就 reuse.如果没有就建一个新的线程加入池中-缓存型池子通常用于执行一些生存期很短的异步型任务 因此在一些面向连接的daemon型SERVER中用得不多。但对于生存期短的异步任务它是Executor的首选。-能reuse的线程必须是timeout IDLE内的池中线程缺省 timeout是60s,超过这个IDLE时长线程实例将被终止及移出池。 注意放入CachedThreadPool的线程不必担心其结束超过TIMEOUT不活动其会自动被终止。 newFixedThreadPool(int) -newFixedThreadPool与cacheThreadPool差不多也是能reuse就用但不能随时建新的线程-其独特之处:任意时间点最多只能有固定数目的活动线程存在此时如果有新的线程要建立只能放在另外的队列中等待直到当前的线程中某个线程终止直接被移出池子-和cacheThreadPool不同FixedThreadPool没有IDLE机制可能也有但既然文档没提肯定非常长类似依赖上层的TCP或UDP IDLE机制之类的所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程多用于服务器-从方法的源代码看cache池和fixed 池调用的是同一个底层 池只不过参数不同:fixed池线程数固定并且是0秒IDLE无IDLE cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力60秒IDLE newScheduledThreadPool(int)-调度型线程池-这个池子里的线程可以按schedule依次delay执行或周期执行 SingleThreadExecutor()-单例线程任意时间池中只能有一个线程-用的是和cache池和fixed池相同的底层池但线程数目是1-1,0秒IDLE无IDLE四、Executor VS ExecutorService VS Executors 正如上面所说这三者均是 Executor 框架中的一部分。Java 开发者很有必要学习和理解他们以便更高效的使用 Java 提供的不同类型的线程池。总结一下这三者间的区别以便大家更好的理解 Executor 和 ExecutorService 这两个接口主要的区别是ExecutorService 接口继承了 Executor 接口是 Executor 的子接口Executor 和 ExecutorService 第二个区别是Executor 接口定义了 execute()方法用来接收一个Runnable接口的对象而 ExecutorService 接口中的 submit()方法可以接受Runnable和Callable接口的对象。Executor 和 ExecutorService 接口第三个区别是 Executor 中的 execute() 方法不返回任何结果而 ExecutorService 中的 submit()方法可以通过一个 Future 对象返回运算结果。Executor 和 ExecutorService 接口第四个区别是除了允许客户端提交一个任务ExecutorService 还提供用来控制线程池的方法。比如调用 shutDown() 方法终止线程池。可以通过 《Java Concurrency in Practice》 一书了解更多关于关闭线程池和如何处理 pending 的任务的知识。Executors 类提供工厂方法用来创建不同类型的线程池。比如: newSingleThreadExecutor() 创建一个只有一个线程的线程池newFixedThreadPool(int numOfThreads)来创建固定线程数的线程池newCachedThreadPool()可以根据需要创建新的线程但如果已有线程是空闲的会重用已有线程。下面给出一个Executor执行Callable任务的示例代码import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*; public class CallableDemo{ public static void main(String[] args){ ExecutorService executorService Executors.newCachedThreadPool(); ListFutureString resultList new ArrayListFutureString(); //创建10个任务并执行 for (int i 0; i 10; i){ //使用ExecutorService执行Callable类型的任务并将结果保存在future变量中 FutureString future executorService.submit(new TaskWithResult(i)); //将任务执行结果存储到List中 resultList.add(future); } //遍历任务的结果 for (FutureString fs : resultList){ try{ while(!fs.isDone);//Future返回如果没有完成则一直循环等待直到Future返回完成 System.out.println(fs.get()); //打印各个线程任务执行的结果 }catch(InterruptedException e){ e.printStackTrace(); }catch(ExecutionException e){ e.printStackTrace(); }finally{ //启动一次顺序关闭执行以前提交的任务但不接受新任务 executorService.shutdown(); } } }
} class TaskWithResult implements CallableString{ private int id; public TaskWithResult(int id){ this.id id; } /** * 任务的具体过程一旦任务传给ExecutorService的submit方法 * 则该方法自动在一个线程上执行 */ public String call() throws Exception { System.out.println(call()方法被自动调用 Thread.currentThread().getName()); //该返回结果将被Future的get方法得到 return call()方法被自动调用任务返回的结果是 id Thread.currentThread().getName(); }
} 五、自定义线程池 自定义线程池可以用ThreadPool Executor类创建它有多个构造方法来创建线程池用该类很容易实现自定义的线程池这里先贴上示例程序 import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit; public class ThreadPoolTest{ public static void main(String[] args){ //创建等待队列 BlockingQueueRunnable bqueue new ArrayBlockingQueueRunnable(20); //创建线程池池中保存的线程数为3允许的最大线程数为5 ThreadPoolExecutor pool new ThreadPoolExecutor(3,5,50,TimeUnit.MILLISECONDS,bqueue); //创建七个任务 Runnable t1 new MyThread(); Runnable t2 new MyThread(); Runnable t3 new MyThread(); Runnable t4 new MyThread(); Runnable t5 new MyThread(); Runnable t6 new MyThread(); Runnable t7 new MyThread(); //每个任务会在一个线程上执行 pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); pool.execute(t6); pool.execute(t7); //关闭线程池 pool.shutdown(); }
} class MyThread implements Runnable{ Override public void run(){ System.out.println(Thread.currentThread().getName() 正在执行。。。); try{ Thread.sleep(100); }catch(InterruptedException e){ e.printStackTrace(); } }
} 运行结果如下 从结果中可以看出七个任务是在线程池的三个线程上执行的。这里简要说明下用到的ThreadPoolExecuror类的构造方法中各个参数的含义。 public ThreadPoolExecutor (int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,BlockingQueueRunnable workQueue) corePoolSize线程池中所保存的核心线程数包括空闲线程。 maximumPoolSize池中允许的最大线程数。 keepAliveTime线程池中的空闲线程所能持续的最长时间。 unit持续时间的单位。 workQueue任务执行前保存任务的队列仅保存由execute方法提交的Runnable任务。 根据ThreadPoolExecutor源码前面大段的注释我们可以看出当试图通过excute方法将一个Runnable任务添加到线程池中时按照如下顺序来处理 1、如果线程池中的线程数量少于corePoolSize即使线程池中有空闲线程也会创建一个新的线程来执行新添加的任务 2、如果线程池中的线程数量大于等于corePoolSize但缓冲队列workQueue未满则将新添加的任务放到workQueue中按照FIFO的原则依次等待执行线程池中有线程空闲出来后依次将缓冲队列中的任务交付给空闲的线程执行 3、如果线程池中的线程数量大于等于corePoolSize且缓冲队列workQueue已满但线程池中的线程数量小于maximumPoolSize则会创建新的线程来处理被添加的任务 4、如果线程池中的线程数量等于了maximumPoolSize有4种处理方式该构造方法调用了含有5个参数的构造方法并将最后一个构造方法为RejectedExecutionHandler类型它在处理线程溢出时有4种方式这里不再细说要了解的自己可以阅读下源码。 总结起来也即是说当有新的任务要处理时先看线程池中的线程数量是否大于corePoolSize再看缓冲队列workQueue是否满最后看线程池中的线程数量是否大于maximumPoolSize。 另外当线程池中的线程数量大于corePoolSize时如果里面有线程的空闲时间超过了keepAliveTime就将其移除线程池这样可以动态地调整线程池中线程的数量。 我们大致来看下Executors的源码newCachedThreadPool的不带RejectedExecutionHandler参数即第五个参数线程数量超过maximumPoolSize时指定处理方式的构造方法如下 public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueueRunnable());
}它将corePoolSize设定为0而将maximumPoolSize设定为了Integer的最大值线程空闲超过60秒将会从线程池中移除。由于核心线程数为0因此每次添加任务都会先从线程池中找空闲线程如果没有就会创建一个线程SynchronousQueueRunnalbe决定的后面会说来执行新的任务并将该线程加入到线程池中而最大允许的线程数为Integer的最大值因此这个线程池理论上可以不断扩大。
再来看newFixedThreadPool的不带RejectedExecutionHandler参数的构造方法如下 public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueueRunnable());
} 它将corePoolSize和maximumPoolSize都设定为了nThreads这样便实现了线程池的大小的固定不会动态地扩大另外keepAliveTime设定为了0也就是说线程只要空闲下来就会被移除线程池敢于LinkedBlockingQueue下面会说。 下面说说几种排队的策略 1、直接提交。缓冲队列采用 SynchronousQueue它将任务直接交给线程处理而不保持它们。如果不存在可用于立即运行任务的线程即线程池中的线程都在工作则试图把任务加入缓冲队列将会失败因此会构造一个新的线程来处理新添加的任务并将其加入到线程池中。直接提交通常要求无界 maximumPoolSizesInteger.MAX_VALUE 以避免拒绝新提交的任务。newCachedThreadPool采用的便是这种策略。 2、无界队列。使用无界队列典型的便是采用预定义容量的 LinkedBlockingQueue理论上是该缓冲队列可以对无限多的任务排队将导致在所有 corePoolSize 线程都工作的情况下将新任务加入到缓冲队列中。这样创建的线程就不会超过 corePoolSize也因此maximumPoolSize 的值也就无效了。当每个任务完全独立于其他任务即任务执行互不影响时适合于使用无界队列。newFixedThreadPool采用的便是这种策略。 3、有界队列。当使用有限的 maximumPoolSizes 时有界队列一般缓冲队列使用ArrayBlockingQueue并制定队列的最大长度有助于防止资源耗尽但是可能较难调整和控制队列大小和最大池大小需要相互折衷需要设定合理的参数。 六、比较Executor和new Thread()
new Thread的弊端如下
a. 每次new Thread新建对象性能差。 b. 线程缺乏统一管理可能无限制新建线程相互之间竞争及可能占用过多系统资源导致死机或oom。 c. 缺乏更多功能如定时执行、定期执行、线程中断。 相比new ThreadJava提供的四种线程池的好处在于
a. 重用存在的线程减少对象创建、消亡的开销性能佳。 b. 可有效控制最大并发线程数提高系统资源的使用率同时避免过多资源竞争避免堵塞。 c. 提供定时执行、定期执行、单线程、并发数控制等功能。 --------------------- 作者不断前行的菜鸟 来源CSDN 原文https://blog.csdn.net/weixin_40304387/article/details/80508236 版权声明本文为作者原创文章转载请附上博文链接 内容解析ByCSDN,CNBLOG博客文章一键转载插件
