理解线程池

为什么要使用线程池？

我们使用一个线程的步骤
1.创建线程
2.使用线程
3.销毁线程
每使用一个线程必须经过这三个步骤，如果步骤1，和步骤3所需要的时间和大于步骤2，我们就得思考，会不会本末倒置，怎么样提高性能？
缩短创建和销毁线程的时间！
当一个线程完成自己的工作后，不去销毁它，让它继续执行别的工作，这样省去了不必要的创建和销毁线程的时间。

线程池的主要目的就是方便管理线程，并实现线程的复用。
线程池的结构：

    private final BlockingQueue<Runnable> workQueue;
    /*任务队列，用来存放等待执行的任务*/
    private final ReentrantLock mainLock = new ReentrantLock();
    /*线程池的状态锁，改变线程池的状态必须使用*/
    private final HashSet<Worker> workers = new HashSet<Worker>();
    /*存放工作集，可以执行的线程都存放在workers里*/
    private final Condition termination = mainLock.newCondition();
    private int largestPoolSize;
    /*用来记录曾经出现过最大的线程数*/
    private long completedTaskCount;
    /*用来记录执行完毕的任务数*/
    private volatile ThreadFactory threadFactory;
    /*用来创建线程的线程工厂*/
    private volatile RejectedExecutionHandler handler;
    /*当拒绝任务时
         AbortPolicy：抛异常。
         CallerRunsPolicy：只用调用者所在线程来运行任务。
         DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
         DiscardPolicy：不处理，直接丢弃。
    */
    private volatile long keepAliveTime;
    /*线程数大于核心线程数时，线程存活的时间*/
    private volatile boolean allowCoreThreadTimeOut;
    /*是否允许核心线程被回收*/
    private volatile int corePoolSize;
    /*核心线程数*/
    private volatile int maximumPoolSize;
    /*最大线程数*/
    private static final RejectedExecutionHandler defaultHandler =new AbortPolicy();
    /*无指定拒绝任务的策略，默认抛异常*/

以上是线程池的主要结构。
线程池怎么运作呢？
这是线程池的所有构造方法：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }


    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

创建好线程池后
假设5个核心线程数，10个最大线程数，时间60秒，名为BQ的阻塞队列。
线程池开始接受任务，
*如果正在运行的线程数量小于 5，那么马上创建线程运行这个任务；
* 如果正在运行的线程数量大于或等于 5，那么将这个任务放入队列BQ；
* 如果这时候队列满了，而且正在运行的线程数量小于 10，那么还是要创建非核心线程立刻运行这个任务；
* 如果队列满了，而且正在运行的线程数量大于或等于 10，那么线程池会抛出异常RejectExecutionException。
* 一段时间后，若线程池中线程数大于5，并且有空闲线程，在60秒后会对空闲的线程进行回收。

线程池怎么样实现线程复用呢？
化简后：

 private final class Worker implements Runnable
{
    private static final long serialVersionUID=6138294804551838833L;
    final Thread thread;
    Runnable firstTask;
    volatile long completedTasks;

    Worker(Runnable firstTask) {
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }
    public void run() {
          runWorker(this);
    }
    final void runWorker(Worker w) {
       Runnable task = w.firstTask;
       w.firstTask = null;
       while (task != null || (task = getTask()) != null) 
       {
            task.run();
       }            
    }

其中getTask()是从阻塞队列取任务的方法；
通过Worker 类中的runWorker()方法，实现线程的循环利用。

若有不正确的地方欢迎指出。