【JVM并发编程专题】——线程池原理

线程池原理——Executors工具类

线程工厂，我们发现线程工厂可以有计划性建立线程并分配到同一个线程组以及命名上保证一个统一规范，方便我们定位线程问题

我们发现大部分线程池的返回都是ThreadPoolExecutor、ForkJoinPool、FinalizableDelegatedExecutorService这几个决定的，那么我后续深入去看看他们的是如何设计出线程池的；

线程池原理——线程池整体规范——Executo接口

public interface ExecutorService extends Executor {

    /**
     * @关闭线程，可以等待任务执行完
     */
    void shutdown();
    /**
     * @立即关闭
     */
    List<Runnable> shutdownNow();

    /**
     * @判断是否关闭
     */
    boolean isShutdown();

    /**
     * @判断是否关闭中
     */
    boolean isTerminated();

    /**
     * 等待关闭，如果还没关闭则抛出异常
     */
    boolean awaitTermination(long timeout, TimeUnit unit)
            throws InterruptedException;

    /**
     * @异步提交一个Callable
     */
    <T> Future<T> submit(Callable<T> task);

    /**
     * @异步提交一个Runnable，并传入返回值的承载对象  
     */
    <T> Future<T> submit(Runnable task, T result);

    /**
     * @异步提交一个Runnable
     */
    Future<?> submit(Runnable task);

    /**
     * @同步立即执行传进来的所有Callable
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
            throws InterruptedException;

    /**
     * @同步立即执行传进来的所有Callable，并给定一个时间限制
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
            throws InterruptedException;


    /**
     * @同步立即执行传进来的所有Callable中的随机其中一个
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
            throws InterruptedException, ExecutionException;

    /**
     * @同步立即执行传进来的所有Callable中的随机其中一个，并给定一个时间限制
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
}

线程池原理——线程池部分实现——AbstractExecutorService抽象类

除了实现了接口以外，还定义了两个新方法，由于我们经常用到submit所以我们分析这个执行的源码

public abstract class AbstractExecutorService implements ExecutorService {
    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }
    /**
     * @以下三个方法全是将task包装给newTaskFor，并调用excutre实现（由实现类自定义）
     * @所以我要重点看看newTaskFor返回的东西
     */
    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }
    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }
    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }
}

他一共是以下类的基本实现

线程池原理——ThreadPoolExecutor——数据存储

/*
 @ 线程池核心数据
*/
private final BlockingQueue<Runnable> workQueue;//任务缓存队列，用来存放等待执行的任务
private final HashSet<Worker> workers = new HashSet<Worker>();  //正在运行的任务


/*
  @ 线程池工具系列
 */
private final ReentrantLock mainLock = new ReentrantLock();   //线程池的主要状态锁，对线程池状态（比如线程池大小、runState等）的改变都要使用这个锁
private volatile ThreadFactory threadFactory;   //线程工厂，用来创建有规范的创建线程
private volatile RejectedExecutionHandler handler; //任务拒绝策略
/*
  @ 线程池配置系列
 */
private volatile long  keepAliveTime;    //线程存活时间   
private volatile boolean allowCoreThreadTimeOut;   //是否允许为核心线程设置存活时间
private volatile int   corePoolSize;     //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）
private volatile int   maximumPoolSize;   //线程池最大能容忍的线程数
private volatile int   poolSize;       //线程池中当前的线程数
private int largestPoolSize;   //用来记录线程池中曾经出现过的最大线程数
private long completedTaskCount;   //用来记录已经执行完毕的任务个数```
/*
   @ 线程池状态系列
   ctl获取一个线程运行状态数字，这里主要想实现用一个数字来存两种数据（线程池状体和worker数量）
   低28位用来表示线程数，高4位用来表示线程池状态
   表明当前线程池的状态，是否处于Running，Shutdown，Stop，Tidying，Terminate五种状态。
   在创建线程以及执行任务时，线程池的状体是参考指标
   详情： https://www.jianshu.com/p/a5a21d48678a
 */
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;

running：能处理新任务，也可以处理阻塞队列中的任务
shutdown：不能接受新任务，但是可以处理阻塞队列中的任务，调用shutdown方法可以到该状态。
stop：不能接受新任务，也不处理阻塞队列中的任务，调用shutdownNow会进入该状态
tidying：所有任务都完成了进入该状态
terminated：从tidying转变过来的最终状态


private static int runStateOf(int c)     { return c & ~CAPACITY; }
private static int workerCountOf(int c)  { return c & CAPACITY; }

【阻塞队列数据结构】
接口：
put(E)   在队列尾部放入元素，若队列满则等待；
take()   取队列头部元素返回，若队列空则等待//核心线程会不断等待；
offer(E) 在队列尾部放入元素，若成功则返回true, 否则false;不阻塞；
poll()   队列头部元素返回，若有元素则返回元素，否则null；不阻塞；//临时线程会调用超时等待
实现类：
ArrayBlockingQueue：是数组实现的，必须构造时传入大小，传入后不可改变。
DelayQueue：实现Delay接口，与排序有关，它是一个可以实现排序的队列，内部就是堆
LinkedBlockingQueue：可以指定大小也可以不指定，内部实现是链表
PriorityBlockingQueue：是有优先级的队列，允许插入元素为null，所有其中对象必须实现Comparable接口。
SynchronousQueue：内部仅容纳一个元素，当一个线程放入元素后就会被阻塞，直到这个元素被消费，又称为同步队列
【woker数据结构】
private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
{
    /**
     * @线程支持
     */
    final Thread thread;
    /**
     *@在线程池设计中一个woker只需要有一个线程支持，但也可以有不同的task
     */
    Runnable firstTask;
    /**
     * @完成任务数量
     */
    volatile long completedTasks;
    /**
     * @worker线程初始化
     * 第一次创建worker时由线程工厂去创建一个线程支持
     */
    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }
    public void run() {
        runWorker(this);
    }
    /**
     * 利用aqs锁赖实现线程状态说明，比如正在执行任务，活跃线程数
     * @return
     */
    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) {
            }
        }
    }
}

线程池原理——ThreadPoolExecutor——execute执行逻辑

当线程池直接调用excute方法或者由某个线程发起submit间接执行excute方法时就回进入这个逻辑

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    int c = ctl.get();
    /*
      核心线程懒加载，如果线程池的线程个数少于corePoolSize则创建新线程执行当前任务，
     */
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    /*
     如果当前活动线程数大于等于corePoolSize，则尝试将任务放入缓存队列
     */
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))//扼杀于摇篮，如果线程池关闭了
            reject(command);
           // 如果线程池的工作线程为零，则调用addWoker，添加是临时线程处理队列的任务
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    /*
       缓存满了就创建临时线程处理这个任务，创建的线程都是一样的，但内部的判断条件不一样
    else if (!addWorker(command, false))
        reject(command);
}

Ps：注意添加核心线程addWorker是true，添加临时线程是false

线程池原理——ThreadPoolExecutor——addWoker逻辑（请求线程执行）

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        /*
          （1）先死循环更新线程工作的数量
         */
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            /*
            线程池是开启的、队列中还有任务、或者传递了一个task，任何一个满足则可以继续添加woker
             */
            if (rs >= SHUTDOWN &&
                !(rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty()))
                return false;
            /**
             * 上面没有阻断 意味着两种情况
             * 1、线程池的状态是running
             * 2、线程池的状态是shutdown，但是队列中还有需要执行的任务，而且跟随这次的worker进来的任务为空（这实质上保证了在shutdown状态下，我们可以执行完队列中的任务）
             */
            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY |
                 /**
                   core 只决定了这里
                 * core是true，用核心线程数检查是否添加worker成功
                 * core是false，用最大线程数检查是否添加worker成功
                 **/
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                    /*
                      原子更新线程worker数量
                     */
                if (compareAndIncrementWorkerCount(c))//增加worker的数量就是在这里
                    break retry;
                c = ctl.get(); 
                if (runStateOf(c) != rs)
                    continue retry;
            }
        }
        /*
          （2）然后开始创建worker
         */
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            /*
              线程工厂内部可能返回的是null，因为开放给用户来配置，所以需要做必要判断
             */
            if (t != null) {
                /*
                 （3）将worker加入到workers里面，由于要保证一大段代码和数据更新的原子性，因此直接锁             是最好的；
                 */
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    int rs = runStateOf(ctl.get());
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) 
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;//这一系列执行成功就会添加线程池
                    }
                } finally {
                    mainLock.unlock();
                }
                /* 
                  添加成功才会启动线程，很明显这里调用了我们熟悉的start哈哈
                 */
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }
    /*
      启动失败就删除这个worker避免占用内存
     */
     private void addWorkerFailed(Worker w) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (w != null)
                workers.remove(w);
            decrementWorkerCount();
            tryTerminate();
        } finally {
            mainLock.unlock();
        }
    }

线程池原理——ThreadPoolExecutor——runWorker详情（Worker线程执行）

Worker实现了runable接口，Worker中的线程是由线程工厂将Worker作为Runnable创建的，也就是读取了Worker的run方法

 public void run() {
            runWorker(this);//ThreadPoolExecutor统一的方法
 }
   final void runWorker(ThreadPoolExecutor.Worker w) {

        /**
         * @优先执行firstTask
         * 每个线程首先把第一个任务我作为task去执行
         */
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            /**
             * @每个worker也会利用getTask去获取阻塞队列中的task
             * 直到阻塞队列中没任务了，当前worker就可以被干掉了
             */
            while (task != null || (task = getTask()) != null) {
                w.lock();
                /**
                 * 判断线程池关闭了，则直接进入设置中断标志位
                 * 否则判断当前线程是否被表
                 * Thread.interrupted()   返回当前线程的中断标志并且重置为false
                 * wt.isInterrupted()     返回线程wt的中断标志
                 */
                if ((runStateAtLeast(ctl.get(), STOP) ||
                        (Thread.interrupted() &&
                                runStateAtLeast(ctl.get(), STOP))) &&
                        !wt.isInterrupted())
                /**
                 * wt.interrupt(); 给线程wt设置一个中断标志，线程仍会继续运行。
                 */
                    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);
        }
    }
  private Runnable getTask() {
        boolean timedOut = false; /
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
            int wc = workerCountOf(c);
            // 对于超过核心线程数量的这些线程，需要进行超时控制
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            /**
             * 当发生超时后的回调
             * 缓存队列中获取任务时发生了超时，那么尝试将workerCount减1,即当前活动线程数减1，
             * 减1成功，则返回null，这就意味着runWorker()方法中的while循环会被退出，其对应的线程就要销毁了，也就是线程池中少了一个线程了
             * 拿到任务的线程则不会被销毁
             */
            if ((wc > maximumPoolSize || (timed && timedOut))
                    && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }
            try {
            /**
                workQueue.take() 核心意义的线程调用永久等待
                workQueue.poll 临时意义的线程调用超时等待
             */
                Runnable r = timed ?
                        workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                        workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {//如果拿出的是超时的则可能被中断，标记为true进入回调
                timedOut = false;
            }
        }
    }
  private void processWorkerExit(Worker w, boolean completedAbruptly) {
        if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
            decrementWorkerCount();

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            completedTaskCount += w.completedTasks;
            workers.remove(w);//删除引用，等待线程销毁
        } finally {
            mainLock.unlock();

        tryTerminate();
        int c = ctl.get();
        if (runStateLessThan(c, STOP)) {
            if (!completedAbruptly) {
                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;
                if (workerCountOf(c) >= min)
                    return; // replacement not needed
            }
            addWorker(null, false);
        }
    }

加锁主要是为了，一些数据统计在遍历的时候会进行各种判断

比如获取活跃线程数
 public int getActiveCount() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            int n = 0;
            for (Worker w : workers)
                if (w.isLocked())
                    ++n;
            return n;
        } finally {
            mainLock.unlock();
        }
 }

线程池原理——线程池异步回调——RunnableFuture（Worker线程执行）

RunnableFuture一共继承了这些（Java最方面的地方就说利用这些接口可以清晰快速了解结构）


重点看看Future接口的应用

public interface Future<V> {
    /**
     * 取消执行这个任务，传入runing是仅取消且必须当前任务正在运行
     */
    boolean cancel(boolean mayInterruptIfRunning);
    /**
     * 判断任务是否被取消
     */
    boolean isCancelled();
    /**
     * 判断任务是否完成。通常用于for循环多个future完成的才继续处理业务
     * @return
     */
    boolean isDone();
    /**
     * 获取回调结果，get会产生阻塞如果任务未完成
     */
    V get() throws InterruptedException, ExecutionException;

    /**
     *  获取回调结果，设置时间限制和单位
     */
    V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
}

RunnableFuture基本结构

    /**
     * state用于实时共享状态
     * NEW：表示一个新的任务，初始状态
     * COMPLETING：当任务被设置结果时，处于COMPLETING状态，这是一个中间状态。
     * NORMAL：表示任务正常结束。
     * EXCEPTIONAL：表示任务因异常而结束
     * CANCELLED：任务还未执行之前就调用了cancel(true)方法，任务处于CANCELLED
     * INTERRUPTING：当任务调用cancel(true)中断程序时，任务处于INTERRUPTING状态，这是一个中间状态。
     * INTERRUPTED：任务调用cancel(true)中断程序时会调用interrupt()方法中断线程运行，任务状态由INTERRUPTING转变为
     */
    private volatile int state;
    private static final int NEW          = 0;
    private static final int COMPLETING   = 1;
    private static final int NORMAL       = 2;
    private static final int EXCEPTIONAL  = 3;
    private static final int CANCELLED    = 4;
    private static final int INTERRUPTING = 5;
    private static final int INTERRUPTED  = 6;
    private Callable<V> callable;
    private Object outcome; // non-volatile, protected by state reads/writes
    private volatile Thread runner;
    private volatile WaitNode waiters;


内部维护了一个链表，主要是拿到future调用get方法后如果结果没有拿到就用链表将这些线程阻塞
static final class WaitNode {
        volatile Thread thread;
        volatile WaitNode next;
        WaitNode() { thread = Thread.currentThread(); }
}
RunnableFuture将实际进行的run方法做了一层外包而从而实现异步编程
public void run() {
        /**
         * cas更新任务状态
         */
        if (state != NEW ||
                !UNSAFE.compareAndSwapObject(this, runnerOffset,
                        null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();//执行原有的call代码，runnable的方法也被适配成了callable
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);//封装结果
            }
        } finally {
            runner = null;
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }
}

/* 先假设调用get()方法的线程为线程T */
private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        long startTime = 0L;    //用来表示超时的开始时间
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
            int s = state;
            if (s > COMPLETING) { //如果任务已经运行结束
                if (q != null)
                    q.thread = null;
                return s;
            }
            else if (s == COMPLETING)//如果任务正在运行
                Thread.yield();
            else if (Thread.interrupted()) {//如果T线程已经被中断
                //将结点出栈，由于使用链表实现的栈，所以是可以将处于中间位置的结点出栈的
                removeWaiter(q);
                throw new InterruptedException();
            }
            else if (q == null) {
                if (timed && nanos <= 0L)//如果设置了超时但是超时时间小于等于0
                    return s;
                q = new WaitNode();//新建一个结点，该节点中的线程是T线程
            }
            else if (!queued)//如果没有入栈
                //把新建的结点压入栈中（链表的头插法），并将waiters指向栈顶
                queued = WAITERS.weakCompareAndSet(this, q.next = waiters, q);
            else if (timed) {//如果设置了超时，并且超时时间大于0
                final long parkNanos;
                if (startTime == 0L) {
                    startTime = System.nanoTime();
                    if (startTime == 0L)
                        startTime = 1L;//这里设置成1的原因是与startTime的初值进行区分
                    parkNanos = nanos;
                } else {
                    long elapsed = System.nanoTime() - startTime;//从开始到现在的时间间隔
                    if (elapsed >= nanos) {//如果时间间隔到了设置的时间
                        removeWaiter(q);
                        return state;
                    }
                    parkNanos = nanos - elapsed;//parkNanos表示还要多久才到超时时间
                }
                if (state < COMPLETING)//将T线程阻塞前进行一次确认，确认任务没完成
                    LockSupport.parkNanos(this, parkNanos);//将线程T阻塞parkNanos纳秒
            }
            else//表示没有设置超时，并且已经将结点压入栈中
                LockSupport.park(this);//将线程T阻塞
        }
    }

线程池原理——总结

AbstractExecutorService抽象类，定义了一些提交任务的基本实现；会将我们的任务封装成RunableTask并返回一个RunableTaskFuture作为异步回调的应用；
线程池数据存储：首先利用ctl实现了28位+4位的线程池状态存储；然后用worker代表工作线程，另外一个代表任务队列；由worker去处理；
**execute逻辑：**主要就是线程状态以及核心数量判断任务是直接丢到阻塞队列还是添加worker，以及依赖数量判断决定worker添加得数量限制逻辑；还有根据阻塞队列成功决定拒绝；
**addWorker逻辑：**无论是核心还是非核心，都是会添加进worker里，只是判断得最大值依据不一样，然后runWorker时得逻辑也是依赖另外一个时间内对核心与临时得状态来决定了阻塞队列得操作方式不一样；
runWorker逻辑：所有worker，只有一个线程但却可以用getTask获取阻塞队列得其他任务；核心和非核心都是依据现在得数量状态做区域判断得，最重要得在于核心线程取出任何是超时等待，非核心不是超时可以阻塞等待直到有任务所以线程可以一直存在；
RunnableFuture逻辑：主要就是包装了原有得用户代码实现任务执行得状态标记，来决定了任何是否执行完；当用户调用get方法时，依据状态决定是否阻塞，并且每个线程都会以链表的形式形成阻塞，最后结果拿到后统一通知所有线程解除阻塞；