线程池实例：使用Executors和ThreadPoolExecutor

一个线程池管理工作线程池，它包含一个队列，使任务等待被执行。一个线程池管理的可运行线程和辅助线程集合执行运行队列中的.

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 提供了使用的 ThreadPoolExecutor 的ExecutorService简单的实现 ，但的 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();                  }          }        } }

这里是实现线程池的例子使用线程池：

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 类。了解更多关于他们在Java Schedule Thread Pool Executor.