Java线程池（一）：初识

1、什么是线程池？

　　简单粗暴的理解就是：装着一个或多个线程的容器，我们称这个容器为线程池。

　　在现实世界中，有着各种各样的“池”，例如游泳池、花池等等。那花池来说，里面种满了各种各样的鲜花，花池本身要做的就是提供一片空地，里面的鲜花是园丁来种植、浇水。不同于花池，线程池不仅仅需要提供一个可以装线程的容器，同时还要承担起管理容器里中线程的职责（例如，新建线程、使用线程等）。

　　一个简单的线程池应该至少包含下面4个部分：

　　　　（1）线程池管理器：创建、销毁并管理线程池，将工作线程放入线程池中

　　　　（2）工作线程：一个可以循环执行任务的线程，在没有任务时进行等待

　　　　（3）任务队列：将没有处理的任务放在任务队列中，提供一种缓冲机制

　　　　（4）任务接口：主要用来规定任务的的入口、任务完成后的收尾工作、任务的执行状态等，工作线程通过该接口调度任务的执行

　　下面举一个简单的例子来理解线程池的工作：

　　　　将线程比作一个机器人，一个线程池就是有很多机器人的工厂，工厂通过新建机器人、分配任务给机器人等方式管理者工厂中的所有机器人。初始时，工厂中并没有机器人。当工厂接到第一个任务时，工厂的管理人员首先新建机器人1号，然后再将任务分配给机器人1号，机器人1号收到任务的命令后就开始工作了。紧接着，工厂接到了第二个任务，管理人员又新建了机器人2号，将第二个任务分配给了机器人2号。当工厂再次接到新的任务时，重复前面的过程。然而，工厂不可能无限制地新建机器人：新建机器人也是需要材料和消耗资源的，资源是有限的；当有新的任务时，前面新建的机器人可能已经完成了交给它的任务而处于空闲状态，因此可以将新的任务分配给处于休息状态的机器人。当工厂中所有的机器人都处于工作状态时，又来了新的任务，怎么办呢？于是，工厂管理者设置了一个任务等候区，新来的任务按顺序在等候区排队。当有机器人完成了任务时，从任务队列中取出一个任务，分配给空闲的机器人，让机器人重新处于工作状态。

2、为什么要使用线程池？

　　从前面工厂的例子中可以看出，线程池为我们带来了以下好处：

　　　　（1）分摊创建线程的开销，加快对请求的响应速度。接到一个任务时，新建了一个线程用于完成任务。当任务完成后，线程处于空闲状态，后面再有新的任务时，不必再新建线程，处于空闲状态的线程可以直接投入工作，省去了新建线程了过程，加快了对请求的响应速度。由于对线程实现了重用，新建线程的开销就被分摊到了多个任务上，线程被重用的次数越多，平均分摊到每个任务中的线程创建的开销就越少。

　　　　（2）解决了资源不足的问题。线程是需要资源的，而资源又是有限的，通过控制线程的数目，避免出现资源不足的问题。

3、如何使用线程池？

　　线程池有着上面的优势，可以自己编码实现一个线程池。然而，编码实现线程池本身就是一项工作量不小的任务，而我们的工作重心是要完成实际的业务。同时，自己编码实现的线程池的正确性、可靠性与稳定性难以保证。于是，大师Doug Lea编写并开源了一个并发程序的代码库，在JDK 1.5之后已加入JDK的豪华套餐，为 java.util.concurrent包。

　　在Java中，线程池类为java.util.concurrent.ThreadPoolExecutor，可以通过该类创建我们需要的线程池：

     public ThreadPoolExecutor(int corePoolSize,
                               int maximumPoolSize,
                               long keepAliveTime,
                               TimeUnit unit,
                               BlockingQueue<Runnable> workQueue,
                               RejectedExecutionHandler handler)

参数说明：

　　corePoolSize : 线程池维护线程的数量（the number of threads to keep in the pool, even if they are idle.）

　　maximumPoolSize ： 线程池维护线程的最大数量（the maximum number of threads to allow in the pool.）

　　keepAliveTime ： 线程池中的线程允许的最大空闲时间（when the number of threads is greater than the core, this is the maximum time that excess idle threads will wait for new tasks before terminating.）

　　unit ： 参数keepAliveTime的时间单位 （the time unit for the keepAliveTime argument.）

　　workQueue ： 任务缓冲队列（the queue to use for holding tasks before they are executed. This queue will hold only the Runnable tasks submitted by the execute method.）

　　handler ： 对拒绝任务的处理策略（the handler to use when execution is blocked because the thread bounds and queue capacities are reached.）

　　通过上面的构造函数，可以构造一个线程池对象threadPool。在Java中，一个任务就是一个Runnable类的对象，具体的业务处理逻辑在该对象的run()方法中实现。通过threadPoool.execute(Runnable)方法，任务被提交到了线程池中并执行。

　　【代码实例】

　　任务类：

 package com.code.threadpool;

 import java.io.Serializable;

 public class ThreadPoolTask implements Runnable, Serializable {

     private static final long serialVersionUID = 1L;

     private Object threadPoolTaskData;

     ThreadPoolTask(Object tasks) {
         this.threadPoolTaskData = tasks;
     }

     public void run() {
         System.out.println("start ..." + threadPoolTaskData);
         try {
             Thread.sleep(2000);
         } catch (Exception e) {
             e.printStackTrace();
         }
         System.out.println("end ..." + threadPoolTaskData);
         threadPoolTaskData = null;
     }

 }

线程池测试类：

 package com.code.threadpool;

 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;

 public class ThreadPoolTest {

     /**
      * 核心线程数量，线程池维护线程的最少数量
      */
     private static final int corePoolSize = 2;

     /**
      * 线程池维护线程的最大数量
      */
     private static final int maxPoolSize = 4;

     /**
      * 线程池维护线程所允许的空闲时间
      */
     private static final int keepAliveTime = 3;

     /**
      * 线程池所使用的缓冲队列的大小
      */
     private static final int workQueueSize = 3;

     /**
      * 线程执行任务后sleep的时间，sleep是为了便于观察程序的运行结果
      */
     private static final int produceTaskSleepTime = 2;

     /**
      * 任务的最大数量
      */
     private static final int produceTaskMaxNumber = 10;

     /**
      * 任务名称的前缀
      */
     private static final String taskNamePrefix = "task@";

     public static void main(String[] args) {

         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(corePoolSize,
                 maxPoolSize, keepAliveTime, TimeUnit.SECONDS,
                 new ArrayBlockingQueue<Runnable>(workQueueSize),
                 new ThreadPoolExecutor.DiscardOldestPolicy());

         for (int i = 0; i < produceTaskMaxNumber; i++) {
             String taskName = taskNamePrefix + (i + 1);
             System.out.println(String.format("put %s", taskName));

             System.out.println("--- before put " + taskName
                     + ", active thread count: " + threadPool.getActiveCount());
             ThreadPoolTask task = new ThreadPoolTask(taskName);
             threadPool.execute(task);
             System.out.println("--- after put " + taskName
                     + ", active thread count: " + threadPool.getActiveCount());

             try {
                 Thread.sleep(produceTaskSleepTime);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

 }

【运行结果】

 put task@1
 --- before put task@1, active thread count: 0
 --- after put task@1, active thread count: 0
 start ...task@1
 put task@2
 --- before put task@2, active thread count: 1
 --- after put task@2, active thread count: 1
 start ...task@2
 put task@3
 --- before put task@3, active thread count: 2
 --- after put task@3, active thread count: 2
 put task@4
 --- before put task@4, active thread count: 2
 --- after put task@4, active thread count: 2
 put task@5
 --- before put task@5, active thread count: 2
 --- after put task@5, active thread count: 2
 put task@6
 --- before put task@6, active thread count: 2
 --- after put task@6, active thread count: 2
 start ...task@6
 put task@7
 --- before put task@7, active thread count: 3
 --- after put task@7, active thread count: 3
 start ...task@7
 put task@8
 --- before put task@8, active thread count: 4
 --- after put task@8, active thread count: 4
 put task@9
 --- before put task@9, active thread count: 4
 --- after put task@9, active thread count: 4
 put task@10
 --- before put task@10, active thread count: 4
 --- after put task@10, active thread count: 4
 end ...task@1
 start ...task@8
 end ...task@2
 start ...task@9
 end ...task@6
 start ...task@10
 end ...task@7
 end ...task@8
 end ...task@9
 end ...task@10

参考资料：

　　1、http://blog.itpub.net/9399028/viewspace-1852029/

　　2、http://blog.csdn.net/newchenxf/article/details/51996950

　　3、http://uule.iteye.com/blog/1123185

　　4、http://www.cnblogs.com/dolphin0520/p/3932921.html

　　5、https://segmentfault.com/a/1190000007120459

本文为原创文章，转载请注明出处：http://www.cnblogs.com/acode/p/6385880.html