Java线程池源码解析

Java-五种线程池，四种拒绝策略，三种阻塞队列
一，五种内置线程池创建模式：
newCachedThreadPool 这是一个可缓存线程池，可以灵活的回收空闲线程，无可回收线程时，新建线程
newSingleThreadExecutor 创建一个单线程化的线程池，保证所有任务按照指定的顺序执行(FIFO,LIFO,优先级)，当要求进程限制时，可以进行使用
newFixedThreadPool 创建一个固定线程数量(最大线程数跟核心线程数相等)，可重用的线程池
newScheduledThreadPool 创建一个可定期或者延时执行任务的线程池
newWorkStealingPool：创建一个拥有多个任务队列的线程池，可以减少连接数，创建当前可用cpu数量的线程来并行执行，适用于大耗时的操作，可以并行来执行

我们来看JDK源码是如何让线程重复使用的：
首先，不同类型线程池的创建实际都是下面这个构造方法依据不同的参数来创建：

下面是线程池的启动代码：

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
        //先判断poolsize 是否有空间，有空间就创建新的thread到pool池里
    if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
    //如果pool池也满了，就将要处理的线程加入到阻塞队列里 
        if (runState == RUNNING && workQueue.offer(command)) {
        //加入队列之后，再次检查线程执行状态，一有机会就从阻塞队列里拿出任务到线程里执行
            if (runState != RUNNING || poolSize == 0)
                ensureQueuedTaskHandled(command);
        }
        else if (!addIfUnderMaximumPoolSize(command))
            reject(command); // is shutdown or saturated
    }
}

而线程的执行只有依靠 Worker这个内部类：

  private final class Worker implements Runnable {
  //中间代码省略
  public void run() {
            try {
                hasRun = true;
                Runnable task = firstTask;
                firstTask = null;
                while (task != null || (task = **getTask()**) != null) {
                    runTask(task);
                    task = null;
                }
            } finally {
                workerDone(this);
            }
        }
    }

重写的Run方法里再着重看看 getTask()方法：

 Runnable getTask() {
    //无限循环的方式不停的去从阻塞队列里获取任务
        for (;;) {
            try {
                int state = runState;
                if (state > SHUTDOWN)
                    return null;
                Runnable r;
                if (state == SHUTDOWN)  // Help drain queue
                    r = workQueue.poll();
                else if (poolSize > corePoolSize || allowCoreThreadTimeOut)
                    r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
                else
                    r = workQueue.take();
                if (r != null)
                    return r;
                if (workerCanExit()) {
                    if (runState >= SHUTDOWN) // Wake up others
                        interruptIdleWorkers();
                    return null;
                }
                // Else retry
            } catch (InterruptedException ie) {
                // On interruption, re-check runState
            }
        }
    }