1.计算机的基础知识

位逻辑运算符:
&:
位与运算符，只有两个操作数都是true，结果才是true。
|:
位或运算符，只有两个操作数都是false，结果才是false。
~:
位非运算符：如果位为0，结果是1，如果位为1，结果是0.
^:
位异或运算：两个数转为二进制，然后从高位开始比较，如果相同则为0，不相同则为1。

位移运算:

无符号左移
>>:
无符号右移
>>>:带符号右移(没有带符号左移这种操作)

二进制:
二进制都是以补码的形式表示的
正数的原码，反码，补码都一样;
要得到负数的补码，必须先求负数的反码，负数的反码；负数的反码按位1改成0，0改成1；负数的补码等于反码+1

2.ThreadPoolExecutor简单示例

public class ThreadPoolExecutorTest {
​
    public static void main(String[] args) {
        BlockingQueue b = new ArrayBlockingQueue(100);
​
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 10, 500000, TimeUnit.SECONDS,
                b, new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
​
            }
        });
        threadPoolExecutor.execute(() -> {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(111111);
        });
​
        threadPoolExecutor.execute(() -> {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(2222222);
        });
​
    }
}

3.ThreadPoolExecutor属性分析

public class ThreadPoolExecutor extends AbstractExecutorService {
​
    //用于保存线程运行状态和当前线程池线程运行的数量
    //高3位用于代表线程的运行状态,低29位代表线程池的线程最大数量
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    //32-3=29
    private static final int COUNT_BITS = Integer.SIZE - 3;
    //00011111111111111111111111111111，高3位为0，低29位为1，代表线程池的线程最大数量
    //参与运算用于得到线程的运行状态和线程池线程的数量
    private static final int CAPACITY   = (1  COUNT_BITS) - 1;
    
    //线程池运行的状态，后面单独分析
    //线程池处于运行状态，11100000000000000000000000000000
    private static final int RUNNING    = -1  COUNT_BITS;
    //线程池处于shutdown状态，00000000000000000000000000000000
    private static final int SHUTDOWN   =  0  COUNT_BITS;
    //线程池处于结束状态，00100000000000000000000000000000
    private static final int STOP       =  1  COUNT_BITS;
    //线程池运行任务为空的时候的状态，01000000000000000000000000000000
    private static final int TIDYING    =  2  COUNT_BITS;
    //线程处于彻底终止的状态，01100000000000000000000000000000
    private static final int TERMINATED =  3  COUNT_BITS;
    
    //获取线程池运行状态，c代表ctl值
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    //获取线程池工作线程数量，c代表ctl值
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    //获取ctl值，rs代表线程的运行状态，wc代表线程池工作线程数量,形成一个32位二进制数
    //高三位代表线程池运行状态，低29位代表线程池工作线程数量
    private static int ctlOf(int rs, int wc) { return rs | wc; }
​
    //传入ctl值和线程某个运行状态，比较ctl值是否小于传入的线程的某个运行状态
    private static boolean runStateLessThan(int c, int s) {
        return c  s;
    }
​
    //传入ctl值和线程运行状态，比较ctl值是否大于传入的线程的某个运行状态
    private static boolean runStateAtLeast(int c, int s) {
        return c >= s;
    }
​
    //判断线程运行状态是否是运行状态，因为RUNNING=-1是最小的状态值
    private static boolean isRunning(int c) {
        return c  SHUTDOWN;
    }
​
    //通过CAS操作将工作线程数+1
    private boolean compareAndIncrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect + 1);
    }
​
    //通过CAS操作将工作线程数-1
    private boolean compareAndDecrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect - 1);
    }
​
    //do-while循环可以强制让工作线程数-1
    private void decrementWorkerCount() {
        do {} while (! compareAndDecrementWorkerCount(ctl.get()));
    }
​
    //线程池的工作队列，在构造方法中初始化
    private final BlockingQueueRunnable> workQueue;
    
    private final ReentrantLock mainLock = new ReentrantLock();
​
    //保存worker的池子
    private final HashSetWorker> workers = new HashSetWorker>();
​
    private final Condition termination = mainLock.newCondition();
​
    //记录线程池生命周期中，线程池运行的线程的最大数量
    private int largestPoolSize;
​
    //线程池完成任务数量
    private long completedTaskCount;
​
    //创建线程工厂
    private volatile ThreadFactory threadFactory;
​
    //线程中断策列
    private volatile RejectedExecutionHandler handler;
​
    //在指定时间单位下，线程存活时间
    private volatile long keepAliveTime;
​
    //核心线程数
    private volatile int corePoolSize;
​
    //最大线程数
    private volatile int maximumPoolSize;
​
    //线程池满了后的中断策列
    private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();
​
    private static final RuntimePermission shutdownPerm =
        new RuntimePermission("modifyThread");
​
    private final AccessControlContext acc;
    
    //当从工作队列中取不到任务时的时候，是否需要回收核心线程
    private volatile boolean allowCoreThreadTimeOut;
    
}    

4.ThreadPoolExecutor构造方法分析

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueueRunnable> 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.acc = System.getSecurityManager() == null ?
            null :
            AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

5.线程池创建线程顺序分析

当我们执行execute方法提交一个线程的时候，首先会判断当前线程池线程数是否超过核心线程数corePoolSize，若是没有超过，则创建新线程，若是超过，则尝试将Runnable提交到工作队列workQueue中。如果工作队列workQueue没有超过容量，则Runnable提交到工作队列中，如果超过了workQueue的容量，则尝试创建线程。如果此时创建的线程小于最大线程数maximumPoolSize，则创建线程，如果超过了maximumPoolSize，则执行拒绝策列。

6.ThreadPoolExecutor.execute方法分析

public void execute(Runnable command) {
    //如果runnable为空，抛出异常
    if (command == null)
        throw new NullPointerException();
    //获取ctl值，该值高3位代表线程池运行状态，低29位代表线程池当前运行线程数量
    int c = ctl.get();
    //CASE1:获取线程池运行线程数量，如果小于核心线程数，则创建线程，addWorker传入参数为core
    //也就是说，线程池不是一上来就把核心线程创建了，必须在提交runnable任务到线程池的时候才一个一个创建
    if (workerCountOf(c)  corePoolSize) {
        //addWorker是创建线程的核心方法，关键点在Worker类的构造方法和runWorker方法的while循环
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    //CASE2:条件1不成立说明核心线程数已满，将任务添加到阻塞队列中。
    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);
    }
    //CASE3:条件1和2都不成立，说明核心线程已创建完全并且任务队列已满
    //调用addWorker创建非核心线程，如果返回false，说明线程数达到最大线程数，执行拒绝策列
    else if (!addWorker(command, false))
        reject(command);
}

6.1.Worker类分析

每个线程的创建都离不开Worker类，该类完全包装了线程运行的所需要的属性，并提供了初始化线程和从阻塞队列中获取被阻塞的线程并执行的一系列方法。

观察该类代码发现，该类继承了AbstractQueuedSynchronizer并实现了Runnable接口，在创建线程的时候，实际Thread类的构造方法包装的就是Worker类自己(我们知道一般Runnable需要被传入到Thread里面的，如:Thread t = new Thread(runnable), t.start()启动线程)。而从execute方法传过来的Runnable实现只是被封装到了firstTask中，创建出来的Thread在执行的时候，调用的start方法也只是启动了该类的runWorker方法，而真正封装我们执行逻辑的firstTask这个Runnable类在后续调用中也只是执行自己的run方法而已，并不再被Thread封装。

worker为什么要继承AbstractQueuedSynchronizer呢？

因为在runWork的方法内，在调用firstTask处理业务逻辑前，会给代码加上独占锁，加这个独占锁的目的是什么呢？因为我们在调用shutDown方法的时候，并不会终止处于运行中的线程。shutDown方法会根据独占锁来判断当前worker是否正在工作。

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    private static final long serialVersionUID = 6138294804551838833L;
​
    //需要创建的线程，该线程封装的Runnable是自己
    final Thread thread;
​
    //execute传入的Runnable，该runnable并不被Thread包装，后续调用自己的run方法。
    Runnable firstTask;
​
    volatile long completedTasks;
​
    Worker(Runnable firstTask) {
        //设置线程池处于运行状态
        setState(-1); 
        //封装execute传入进来的包含实际逻辑的Runnable
        this.firstTask = firstTask;
        //创建一个线程，这里注意，线程封装的Runnable是自己
        //示例使用Executors.defaultThreadFactory()
        this.thread = getThreadFactory().newThread(this);
    }
    //被thread属性封装后调用start方法后，会自动启动该run方法，执行后续逻辑
    //后续逻辑会调用firstTask.run()方法启动实际业务逻辑
    public void run() {
        runWorker(this);
    }
​
    protected boolean isHeldExclusively() {
        return getState() != 0;
    }
​
    protected boolean tryAcquire(int unused) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }
​
    protected boolean tryRelease(int unused) {
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }
​
    public void lock()        { acquire(1); }
    public boolean tryLock()  { return tryAcquire(1); }
    public void unlock()      { release(1); }
    public boolean isLocked() { return isHeldExclusively(); }
​
    void interruptIfStarted() {
        Thread t;
        if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
            try {
                t.interrupt();
            } catch (SecurityException ignore) {
            }
        }
    }
}

6.2.addWorker方法分析

addWorker是创建线程的核心方法，一个worker代表一个线程，而workers这个全局变量可以代表线程池，只有向workers里面添加worker成功的时候，才能代表创建线程成功了。addWorker在执行过程中，会根据线程池状态和线程池数量判断是否能创建线程，创建线程成功会将记录线程池状态和数量的ctl值+1，并将worker加入到workers里面，更新线程池生命周期内线程池线程的最大数量，然后启动线程执行任务。

addWorker的core参数代表是否是在创建核心线程，core为true代表创建核心线程，false代表阻塞队列已满，创建非核心线程。

返回值: true代表创建线程并启动成功，false代表创建线程失败。

什么时候返回false呢？
CASE1.线程池状态rs>SHUTDOWN；
CASE2.线程池状态为SHUTDOWN的时候，阻塞队列没有任务了,为空;
CASE3.线程池状态为SHUTDOWN的时候，execute提交的Runnable(被封装到firstTask里面)不为空;
CASE4.如果是创建核心线程，此时已经超过核心线程数；如果是创建非核心线程，此时已经超过最大线程数;
CASE5.ThreadFactory创建线程为空,这里一般是我们自定义线程工厂的时候出的问题;

private boolean addWorker(Runnable firstTask, boolean core) {
    //retry代码除了检查是否能创建线程外，还负责将ctl值+1，如果不能创建线程，则返回false;
    retry:
    for (;;) {
        //获取当前ctl值
        int c = ctl.get();
        //获取当前线程池运行状态
        int rs = runStateOf(c);
        //CASE1.线程池状态rs>SHUTDOWN；返回false;
        //CASE2.线程池状态为SHUTDOWN的时候，阻塞队列没有任务了,为空;
        //CASE3.线程池状态为SHUTDOWN的时候，execute提交的Runnable(被封装到firstTask里面)不为空;
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;
​
        //循环判断是否能将ctl+1设置成功
        for (;;) {
            //获取当前运行中的线程数量
            int wc = workerCountOf(c);
            //条件1:wc >= CAPACITY基本不可能，CAPACITY为理论上的最大线程数，一个5亿级的数字
            //CASE4.根据core参数，如果是创建核心线程，此时已经超过核心线程数，则返回false
            //如果是创建非核心线程，此时已经超过最大线程数，则返回false
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            //条件成立，说明给ctl修改+1成功了，代表给线程数+1设置成功了，可以退出循环创建线程了
            //如果在执行这段代码的时候，线程池状态正巧被改了，这里也会失败，因为ctl的高3位代表的是线程状态
            if (compareAndIncrementWorkerCount(c))
                break retry;
            //如果上面设置线程数+1失败，则实时获取线程状态并和当前的比较
            c = ctl.get();  
            //状态被改变了跳到retry再次判断是否允许创建线程
            if (runStateOf(c) != rs)
                continue retry;
        }
    }
    //代码走到这里代表已经允许创建线程了
    
    //表示创建的worker是否已经启动,启动也代表线程创建成功了
    boolean workerStarted = false;
    //添加worker到worker队列是否成功的状态
    boolean workerAdded = false;
    //局部变量
    Worker w = null;
    try {
        //构建work对象
        w = new Worker(firstTask);
        //获取worker的构造方法创建的线程
        final Thread t = w.thread;
        //这里加了这段判断是为了防止自己实现的TreadFactory有bug导致创建线程失败
        if (t != null) {
            //向works这个hashset里面添加works的时候，需要全局加锁，以下代码线程并不安全
            //该段代码我的理解就是为了维护largestPoolSize这个值，记录线程池生命周期中，
            //线程池运行的线程的最大数量
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                //获取当前线程池状态
                int rs = runStateOf(ctl.get());
                //检查线程池状态必须是RUNNING或者处于SHUTDOWN的时候，并没有提交具体的任务
                if (rs  SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    //防止人为定义线程工厂创建线程并启动了start方法的情况
                    if (t.isAlive()) 
                        throw new IllegalThreadStateException();
                    //向线程池添加worker
                    workers.add(w);
                    //获取线程池线程数量
                    int s = workers.size();
                    //如果线程池线程数量>记录的值,更新线程池生命周期内最大线程记录数
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    //表示向线程池中添加线程成功了
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                //启动线程,该方法实际会启动worker类的run方法，然后执行runWorker方法
                t.start();
                //设置线程启动状态为成功
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            //后面再分析
            addWorkerFailed(w);
    }
    return workerStarted;
}

6.3.runWorker方法分析

addWorker方法创建线程成功，Worker类的Thread会调用start方法启动自己的run方法，因为Worker类实现了Runnable接口，run方法里面调用了runWorker方法。实际我们execute方法传入的Runnable被封装到了Worker类的firstTask属性里面。然后在runWorker里面调用run方法启动具体的逻辑，注意这里并没用再用Thrad封装Runnable了。线程启动后，会一直运行While循环，循环第一次运行自己传入的Runnable，第二次及之后则通过getTask方法从任务队列种获取具体的Runnable任务了。一旦While循环内发生异常或者getTask返回空，则会调用processWorkerExit执行线程销毁逻辑。getTask方法获取不到具体任务的线程都可被认为是空闲线程。

final void runWorker(Worker w) {
    //wt=w.thread
    Thread wt = Thread.currentThread();
    //execute实际传入的包含业务逻辑的Runnable，该Runnable不再被Thread包装，调用自己的run方法
    Runnable task = w.firstTask;
    //引用设置为null，帮助gc
    w.firstTask = null;
    //先调用unlock方法设置当前独占线程为空，线程运行状态为0
    w.unlock();
    //线程退出状态，true代表线程因为异常退出了
    boolean completedAbruptly = true;
    try {
        //线程被创建并启动后就一直