线程池深度解析

概述

线程池优点

1. 减少了每个任务的调用开销，在执行大量异步任务时候提供改进的性能。
2. 限制和管理线程资源
3. 维护基本的统计信息，如多少任务已完成。

默认线程池类型

• newCacheThreaddPool:缓存线程池，无界线程池。默认60s未使用的线程会被终止并被回收
• newFixedThreadPool:固定大小线程池。如果池中线程都在提交任务，则后续任务放置于等待队列。如果线程执行时候发生异常，则后续线程替代。
• newSingleThreadExecutor:单个工作线程用于执行。其他类似于newFixedThreadPool

线程池构造参数

public ThreadPoolExecutor(int corePoolSize, //核心线程数
                              int maximumPoolSize, //最大线程数
                              long keepAliveTime, //非核心线程在等待新任务的最长时间
                              TimeUnit unit, //keepAliveTime的时间单位
                              BlockingQueue<Runnable> workQueue //保存未执行任务的队列，只接受Runable任务
                         ) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

线程池的运行机制

1. 当新任务进来时候，先判断池内是否达到核心线程数，没有达到则新建
2. 如果已达到，放入等待队列
3. 如果等待队列已满，则查看池内是否达到最大线程数
4. 未满，则新建非核心线程。满了，则拒绝策略

方法解析

参数说明

    
//ctl一个原子整数，低位代表有效线程数，高位代表线程状态
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;

// runState is stored in the high-order bits
//接受新任务，并处理排队任务
private static final int RUNNING    = -1 << COUNT_BITS;
//不接受新任务，但处理排队任务
private static final int SHUTDOWN   =  0 << COUNT_BITS;
//不接受，不处理任务，并中断正在执行任务
private static final int STOP       =  1 << COUNT_BITS;
//所有任务都已终止，workCount为0
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;

execute

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
    	//判断是否小于核心线程数
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            //get操作是非原子性操作，此时是核心线程添加失败才会走到
            //失败原因可能是shutdown或者大于核心线程数
            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);
    }

addWorker

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
    	//自旋的方式去处理线程
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // 判断是否是shutdown及以上状态
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;
		  //通过自旋的方式 尝试去worker+1
            for (;;) {
                int wc = workerCountOf(c);
                //核心线程与core~比较
                //非核心与max~比较
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                //CAS的方式 尝试N+1
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                //重新读取，以及判断状态
                c = ctl.get();  
                if (runStateOf(c) != rs)
                    continue retry;
            }
        }
	   //这里，代表worker+1，走后续处理
        boolean workerStarted = false;
    	//是否构造成功
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            //真正执行任务的线程
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        //HashSet容器
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        //赋值-添加成功
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

Worker

/**
* AQS的一个子类，用于存放Runnable并执行
*/
private final class Worker  extends AbstractQueuedSynchronizer implements Runnable {
    Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
        	//执行外部任务的线程
            this.thread = getThreadFactory().newThread(this);
        }
    }

runWorker

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); 
        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;
                    //代表任务处理完成+1
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

getTask

private Runnable getTask() {
        boolean timedOut = false; 
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            //线程池的状态满足条件，则worker以CAS的方式数量-1
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
            int wc = workerCountOf(c);
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }
            try {
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

shutdown/shutdownNow

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    //排他锁，确保一个线程进行操作
    mainLock.lock();
    try {
        checkShutdownAccess();
        //shutdownNow相比修改状态不同
        advanceRunState(SHUTDOWN);
        //遍历worker，中断通知
        interruptIdleWorkers();
        onShutdown();
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
}
    
    
public List<Runnable> shutdownNow() {
    //等待执行的任务列表，原队列中的任务会被移除
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(STOP);
        interruptWorkers();
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
    return tasks;
}