8、ThreadPoolExecutor源码_workercountof(recheck) == 0

一、线程池有哪些类

1、可缓存线程池（NewCachedThreadPool）

创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行
很多短期异步任务的程序而言，这些线程池通常可提高程序性能。

2、 指定工作线程的线程池（NewFixedThreadPool）

创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。

3、定时的线程池（newScheduledThreadPool）

创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

4、ThreadPoolExecutor

ThreadPoolExecutor与前几个线程池对比要更灵活

二、ThreadPoolExecutor解决什么问题

创建一个新的线程可以通过继承Thread类或者实现Runnable接口来实现，这两种方式创建的线程在运行结束后会被虚拟机销毁，进行垃圾回收，如果线程数量过多，频繁的创建和销毁线程会浪费资源，降低效率。而线程池的引入就很好解决了上述问题，线程池可以更好的创建、维护、管理线程的生命周期，做到复用，提高资源的使用效率，也避免了开发人员滥用new关键字创建线程的不规范行为。

1、ThreadPoolExecutor数据结构

ThreadPoolExecutor数据结构有 HashSet、BlockingQueue、Worker、AbstractQueuedSynchronizer构成。

2、ThreadPoolExecutor执行流程

1、任务添加 - 当线程池任务数小于核心线程数时，Worker 是继承Runnable的包装类，每一个任务都使用Worker包装起来，然后将包装对象存入HashSet中，直接唤醒其线程执行。 

2、任务添加 - 当线程池任务数大于核心线程数时，执行方法直接放入BlockingQueue队列中，排队执行。如果队列满了执行队列拒绝策略。

3、线程回收- 当执行线程大于核心线程 或者 线程池关闭 或者 核心线程keepAliveTimeOut超时时候触发interruptIdleWorkers方法。 注意点interruptIdleWorkers回收原则是线程是否被发出中断请求，如果被发出中断请求执行回收。

三、ThreadPoolExecutor类重点方法列举

四、线程池源码解读

1、任务添加

1、当前线程数小于核心线程数，addWoker直接添加入Hashset中，直接唤醒addWorker线程执行。

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
 
        //线程小于核心线程数，addWorker添加Hashset直接唤醒线程执行
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        
        //任务添加到队列
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
 
        //任务添加队列失败执行拒绝策略
        else if (!addWorker(command, false))
            reject(command);
}

2、队列任务执行

线程池队列线程执行情况

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // 如果线程池停止执行线程回收
                // 如果当前线程被中断
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
  }

3、线程池线程回收

线程回收方法是线程安全的，如果线程被中断执行回收。

//线程池线程回收
private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
}