理解线程池

为什么要使用线程池？

我们使用一个线程的步骤

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) {
<
a1a1
span class="hljs-keyword">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()方法，实现线程的循环利用。

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