使用Executors和ThreadPoolExecutor2

线程池负责管理工作线程，包含一个等待执行的任务队列。线程池的任务队列是一个Runnable集合，工作线程负责从任务队列中取出并执行Runnable对象。

java.util.concurrent.executors 提供了 java.util.concurrent.executor 接口的一个Java实现，可以创建线程池。下面是一个简单示例：

首先创建一个Runable 类：

WorkerThread.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

package com.journaldev.threadpool; public class WorkerThread implements Runnable {      private String command;      public WorkerThread(String s){          this .command=s;      }      @Override      public void run() {          System.out.println(Thread.currentThread().getName()+ " Start. Command = " +command);          processCommand();          System.out.println(Thread.currentThread().getName()+ " End." );      }      private void processCommand() {          try {              Thread.sleep( 5000 );          } catch (InterruptedException e) {              e.printStackTrace();          }      }      @Override      public String toString(){          return this .command;      } }

下面是一个测试程序，从 Executors 框架中创建固定大小的线程池：

SimpleThreadPool.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

package com.journaldev.threadpool; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class SimpleThreadPool {      public static void main(String[] args) {          ExecutorService executor = Executors.newFixedThreadPool( 5 );          for ( int i = 0 ; i < 10 ; i++) {              Runnable worker = new WorkerThread( "" + i);              executor.execute(worker);            }          executor.shutdown();          while (!executor.isTerminated()) {          }          System.out.println( "Finished all threads" );      } }

在上面的程序中，我们创建了包含5个工作线程的固定大小线程池。然后，我们向线程池提交10个任务。由于线程池的大小是5，因此首先会启动5个工作线程，其他任务将进行等待。一旦有任务结束，工作线程会从等待队列中挑选下一个任务并开始执行。

以上程序的输出结果如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

pool- 1 -thread- 2 Start. Command = 1 pool- 1 -thread- 4 Start. Command = 3 pool- 1 -thread- 1 Start. Command = 0 pool- 1 -thread- 3 Start. Command = 2 pool- 1 -thread- 5 Start. Command = 4 pool- 1 -thread- 4 End. pool- 1 -thread- 5 End. pool- 1 -thread- 1 End. pool- 1 -thread- 3 End. pool- 1 -thread- 3 Start. Command = 8 pool- 1 -thread- 2 End. pool- 1 -thread- 2 Start. Command = 9 pool- 1 -thread- 1 Start. Command = 7 pool- 1 -thread- 5 Start. Command = 6 pool- 1 -thread- 4 Start. Command = 5 pool- 1 -thread- 2 End. pool- 1 -thread- 4 End. pool- 1 -thread- 3 End. pool- 1 -thread- 5 End. pool- 1 -thread- 1 End. Finished all threads

从输出结果看，线程池中有五个名为“pool-1-thread-1”…“pool-1-thread-5”的工作线程负责执行提交的任务。

Executors 类使用 ExecutorService  提供了一个 ThreadPoolExecutor 的简单实现，但 ThreadPoolExecutor 提供的功能远不止这些。我们可以指定创建 ThreadPoolExecutor 实例时活跃的线程数，并且可以限制线程池的大小，还可以创建自己的 RejectedExecutionHandler 实现来处理不适合放在工作队列里的任务。

下面是一个 RejectedExecutionHandler 接口的自定义实现：

RejectedExecutionHandlerImpl.java

1 2 3 4 5 6 7 8 9 10 11 12 13

package com.journaldev.threadpool; import java.util.concurrent.RejectedExecutionHandler; import java.util.concurrent.ThreadPoolExecutor; public class RejectedExecutionHandlerImpl implements RejectedExecutionHandler {      @Override      public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {          System.out.println(r.toString() + " is rejected" );      } }

ThreadPoolExecutor 提供了一些方法，可以查看执行状态、线程池大小、活动线程数和任务数。所以，我通过一个监视线程在固定间隔输出执行信息。

MyMonitorThread.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

package com.journaldev.threadpool; import java.util.concurrent.ThreadPoolExecutor; public class MyMonitorThread implements Runnable {      private ThreadPoolExecutor executor;      private int seconds;      private boolean run= true ;      public MyMonitorThread(ThreadPoolExecutor executor, int delay)      {          this .executor = executor;          this .seconds=delay;      }      public void shutdown(){          this .run= false ;      }      @Override      public void run()      {          while (run){                  System.out.println(                      String.format( "[monitor] [%d/%d] Active: %d, Completed: %d, Task: %d, isShutdown: %s, isTerminated: %s" ,                          this .executor.getPoolSize(),                          this .executor.getCorePoolSize(),                          this .executor.getActiveCount(),                          this .executor.getCompletedTaskCount(),                          this .executor.getTaskCount(),                          this .executor.isShutdown(),                          this .executor.isTerminated()));                  try {                      Thread.sleep(seconds* 1000 );                  } catch (InterruptedException e) {                      e.printStackTrace();                  }          }      } }

下面是使用 ThreadPoolExecutor 的线程池实现示例：

WorkerPool.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

package com.journaldev.threadpool; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.Executors; import java.util.concurrent.ThreadFactory; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class WorkerPool {      public static void main(String args[]) throws InterruptedException{          //RejectedExecutionHandler implementation          RejectedExecutionHandlerImpl rejectionHandler = new RejectedExecutionHandlerImpl();          //Get the ThreadFactory implementation to use          ThreadFactory threadFactory = Executors.defaultThreadFactory();          //creating the ThreadPoolExecutor          ThreadPoolExecutor executorPool = new ThreadPoolExecutor( 2,4 , 10 , TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2 ), threadFactory, rejectionHandler);          //start the monitoring thread          MyMonitorThread monitor = new MyMonitorThread(executorPool, 3 );          Thread monitorThread = new Thread(monitor);          monitorThread.start();          //submit work to the thread pool          for ( int i= 0 ; i< 10 ; i++){              executorPool.execute( new WorkerThread( "cmd" +i));          }          Thread.sleep( 30000 );          //shut down the pool          executorPool.shutdown();          //shut down the monitor thread          Thread.sleep( 5000 );          monitor.shutdown();      } }

请注意：在初始化 ThreadPoolExecutor 时，初始线程池大小设为2、最大值设为4、工作队列大小设为2。所以，如果当前有4个任务正在运行而此时又有新任务提交，工作队列将只存储2个任务和其他任务将交由RejectedExecutionHandlerImpl 处理。

程序执行的结果如下，确认了上面的结论：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

pool-1-thread-1 Start. Command = cmd0 pool-1-thread-4 Start. Command = cmd5 cmd6 is rejected pool-1-thread-3 Start. Command = cmd4 pool-1-thread-2 Start. Command = cmd1 cmd7 is rejected cmd8 is rejected cmd9 is rejected [monitor] [0 /2 ] Active: 4, Completed: 0, Task: 6, isShutdown: false , isTerminated: false [monitor] [4 /2 ] Active: 4, Completed: 0, Task: 6, isShutdown: false , isTerminated: false pool-1-thread-4 End. pool-1-thread-1 End. pool-1-thread-2 End. pool-1-thread-3 End. pool-1-thread-1 Start. Command = cmd3 pool-1-thread-4 Start. Command = cmd2 [monitor] [4 /2 ] Active: 2, Completed: 4, Task: 6, isShutdown: false , isTerminated: false [monitor] [4 /2 ] Active: 2, Completed: 4, Task: 6, isShutdown: false , isTerminated: false pool-1-thread-1 End. pool-1-thread-4 End. [monitor] [4 /2 ] Active: 0, Completed: 6, Task: 6, isShutdown: false , isTerminated: false [monitor] [2 /2 ] Active: 0, Completed: 6, Task: 6, isShutdown: false , isTerminated: false [monitor] [2 /2 ] Active: 0, Completed: 6, Task: 6, isShutdown: false , isTerminated: false [monitor] [2 /2 ] Active: 0, Completed: 6, Task: 6, isShutdown: false , isTerminated: false [monitor] [2 /2 ] Active: 0, Completed: 6, Task: 6, isShutdown: false , isTerminated: false [monitor] [2 /2 ] Active: 0, Completed: 6, Task: 6, isShutdown: false , isTerminated: false [monitor] [0 /2 ] Active: 0, Completed: 6, Task: 6, isShutdown: true , isTerminated: true [monitor] [0 /2 ] Active: 0, Completed: 6, Task: 6, isShutdown: true , isTerminated: true

请注意活跃线程、已完成线程和任务完成总数的变化。我们可以调用 shutdown() 结束所有已提交任务并终止线程池。

如果希望延迟执行或定期运行任务，那么可以使用 ScheduledThreadPoolExecutor 类。