理解线程池

为什么要使用线程池？

我们使用一个线程的步骤
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()方法，实现线程的循环利用。

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