Java线程池应用

Posted 2020-06-14

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);