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