Java线程池应用

Executors工具类用于创建Java线程池和定时器。

newFixedThreadPool:创建一个可重用固定线程数的线程池,以共享的无界队列方式来运行这些线程。在任意点,在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务,则在有可用线程之前,附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止,那么一个新线程将代替它执行后续的任务(如果需要)。在某个线程被显式地关闭之前,池中的线程将一直存在。

创建一个固定大小的线程池来执行10个任务: 

实例:

 1 ExecutorService threadPool = Executors.newFixedThreadPool(3);
 2         for (int j = 0; j < 10; j++) {
 3             final int task = j;
 4             threadPool.execute(new Runnable() {
 5                 @Override
 6                 public void run() {
 7                     for (int i = 0; i < 10; i++) {
 8                         try {
 9                             Thread.sleep(200);
10                         } catch (InterruptedException e) {
11                             // TODO Auto-generated catch block
12                             e.printStackTrace();
13                         }
14                         System.out.println(Thread.currentThread().getName()+"is looping of "+ i +" task of "+task);
15                     }
16                     
17                 }
18             });
19         }

newCachedThreadPool 创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言,这些线程池通常可提高程序性能。调用 execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此,长时间保持空闲的线程池不会使用任何资源。注意,可以使用 ThreadPoolExecutor 构造方法创建具有类似属性但细节不同(例如超时参数)的线程池。 

创建10个线程的缓存池执行10个任务

实例:

 1 ExecutorService threadPool = Executors.newCachedThreadPool();
 2         for (int j = 0; j < 10; j++) {
 3             final int task = j;
 4             threadPool.execute(new Runnable() {
 5                 @Override
 6                 public void run() {
 7                     for (int i = 0; i < 10; i++) {
 8                         try {
 9                             Thread.sleep(200);
10                         } catch (InterruptedException e) {
11                             // TODO Auto-generated catch block
12                             e.printStackTrace();
13                         }
14                         System.out.println(Thread.currentThread().getName()+"is looping of "+ i +" task of "+task);
15                     }
16                     
17                 }
18             });
19         }

newSingleThreadExecutor 创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程。(注意,如果因为在关闭前的执行期间出现失败而终止了此单个线程,那么如果需要,一个新线程将代替它执行后续的任务)。可保证顺序地执行各个任务,并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool(1) 不同,可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。

创建一个线程执行十个任务(可以用于让一个死去线程复活重新执行,实际是启动一个新的线程)

实例:

 1 ExecutorService threadPool = Executors.newSingleThreadExecutor();
 2         for (int j = 0; j < 10; j++) {
 3             final int task = j;
 4             threadPool.execute(new Runnable() {
 5                 @Override
 6                 public void run() {
 7                     for (int i = 0; i < 10; i++) {
 8                         try {
 9                             Thread.sleep(200);
10                         } catch (InterruptedException e) {
11                             // TODO Auto-generated catch block
12                             e.printStackTrace();
13                         }
14                         System.out.println(Thread.currentThread().getName()+"is looping of "+ i +" task of "+task);
15                     }
16                     
17                 }
18             });
19         }

shutdown和shutdownNow的区别

shutdown:启动一次顺序关闭,执行以前提交的任务,但不接受新任务。如果已经关闭,则调用没有其他作用。

shutdownNow:试图停止所有正在执行的活动任务,暂停处理正在等待的任务,并返回等待执行的任务列表。无法保证能够停止正在处理的活动执行任务,但是会尽力尝试。例如,通过 Thread.interrupt() 来取消典型的实现,所以任何任务无法响应中断都可能永远无法终止。  

ScheduledExecutorService线程池定时器。schedule 方法使用各种延迟创建任务,并返回一个可用于取消或检查执行的任务对象。scheduleAtFixedRate 和scheduleWithFixedDelay 方法创建并执行某些在取消前一直定期运行的任务。

schedule 创建并执行在给定延迟后启用的一次性操作。

 1 ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
 2         for (int i = 0; i < 10; i++) {
 3             final int timer = i;*/
 4             /*scheduledThreadPool.schedule(new Runnable() {
 5                 @Override
 6                 public void run() {
 7                     try {
 8                         Thread.sleep(20);
 9                     } catch (InterruptedException e) {
10                         // TODO Auto-generated catch block
11                         e.printStackTrace();
12                     }
13                     System.out.println(Thread.currentThread().getName()+" " +timer);
14                 }
15             }, 2, TimeUnit.SECONDS);

scheduleAtFixedRate 创建并执行一个在给定初始延迟后首次启用的定期操作,后续操作具有给定的周期;也就是将在 initialDelay 后开始执行,然后在 initialDelay+period 后执行,接着在 initialDelay + 2 * period 后执行,依此类推。如果任务的任何一个执行遇到异常,则后续执行都会被取消。否则,只能通过执行程序的取消或终止方法来终止该任务。如果此任务的任何一个执行要花费比其周期更长的时间,则将推迟后续执行,但不会同时执行。  

 1 scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
 2                 
 3                 @Override
 4                 public void run() {
 5                     try {
 6                         Thread.sleep(20);
 7                     } catch (InterruptedException e) {
 8                         // TODO Auto-generated catch block
 9                         e.printStackTrace();
10                     }
11                     System.out.println(Thread.currentThread().getName());
12                 }
13             }, 2, 3, TimeUnit.SECONDS);

scheduleWithFixedDelay 创建并执行一个在给定初始延迟后首次启用的定期操作,随后,在每一次执行终止和下一次执行开始之间都存在给定的延迟。如果任务的任一执行遇到异常,就会取消后续执行。否则,只能通过执行程序的取消或终止方法来终止该任务。

 1 scheduledThreadPool.scheduleWithFixedDelay(new Runnable() {
 2                 
 3                 @Override
 4                 public void run() {
 5                     try {
 6                         Thread.sleep(20);
 7                     } catch (InterruptedException e) {
 8                         // TODO Auto-generated catch block
 9                         e.printStackTrace();
10                     }
11                     System.out.println(Thread.currentThread().getName());
12                 }
13             }, 2, 3, TimeUnit.SECONDS);

 

    原文作者:ngulc
    原文地址: https://www.cnblogs.com/lcngu/p/5196682.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞