线程池原理（源码）

线程池核心参数

• corePoolSize：核心线程数
• maximumPoolSize：最大线程数
• keepAliveTime：线程最大空闲时间（默认针对非核心线程）
• unit：最大空闲时间的单位
• workQueue：阻塞队列
• threadFactory：线程工厂
• handler：拒绝策略

线程池任务处理流程

线程池执行任务的方法是execute方法，并传递任务。如果想看懂线程池的核心源码，需要查看的就是线程池的核心属性。

	// 线程池的核心属性
	/**
	* 一个int类型的ctl，存储了线程池的两个核心属性
	* 线程池状态：基于ctl的高三位存储
	* 工作线程个数：基于ctl的低29位，存储工作线程，最大工作线程个数也就是2^29
	*/
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    // Integer.SIZE = 32
    private static final int COUNT_BITS = Integer.SIZE - 3;
    // COUNT_MASK：就是2^29，也就是线程池中工作线程数的最大值
    private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;

    // 下面五个属性是线程池的状态
    private static final int RUNNING    = -1 << COUNT_BITS;
    // 正常的接受，执行任务，正常处理工作队列的任务
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    // 执行shutdown方法，从running变为shutdown状态。不接受新的任务，可以正常地处理任务（在变成shutdown之前接受到的任务）
    // 可以正常处理工作队列的任务
    // 空闲线程会被中断
    private static final int STOP       =  1 << COUNT_BITS;
    // 执行shutdownNow方法才会从running变为stop状态。
    // 不接受新的任务，正在执行任务的线程全部强制中断，（不一定停下来，但是中断标记位设置为ture）
    // 工作队列的任务不处理，直接作为返回值
    private static final int TIDYING    =  2 << COUNT_BITS;
    // 工作线程为0个并且工作队列任务处理完毕，才会从shutdown变为tidying状态
    // 工作线程为0个，才会从stop状态变为tidying状态
    // tidying状态为过渡状态
    private static final int TERMINATED =  3 << COUNT_BITS;
    // 执行terminated方法，从tidying状态变为terminated状态。线程池凉凉

线程池的工作状态之间的关系可以用一张概括（线程池的生命周期）：

线程池的执行流程：

    public void execute(Runnable command) { // command就是任务
    	// 非空检验
        if (command == null)
            throw new NullPointerException();
        // 拿到存储线程池状态以及工作线程个数的核心属性
        int c = ctl.get();
        // 判断当前工作线程数是否小于核心线程数
        if (workerCountOf(c) < corePoolSize) {
        	// 创建工作线程
        	// command：传递进来的任务
        	// true：创建核心线程，false：创建非核心线程
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }

		// 如果核心线程数已经达到预期的数值，任务就要扔到工作队列当中
		// 如果线程池工作状态为running，直接将任务扔到工作队列当中
        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);
    }

根据以上分析，线程池的处理流程为：核心 - 工作队列 - 非核心 - 拒绝策略。

创建工作线程池流程

• 判断线程池状态是否符合要求
• 判断工作线程个数是否符合要求，并且基于cas保证原子性
• new Worker创建工作线程，并将Worker对象添加到HashSet中，使用ReentrantLock保证安全
• 拿到Worker对象中的thread，执行start方法，启动线程

核心线程，非核心线程都是基于addWorker创建的。

private boolean addWorker(Runnable firstTask, boolean core) {
		// 判断线程池的状态，再判断线程个数
		// 外层for循环在判断线程池的状态，内层for循环在判断线程池的个数，然后基于cas修改ctl属性，给工作线程 + 1。
        retry:
        for (int c = ctl.get();;) {
            // Check if queue empty only if necessary.
            // 解决在shutdown状态下，没有工作线程，要构建一个线程处理工作队列任务的情况
            if (runStateAtLeast(c, SHUTDOWN) // rs:高三位的线程池状态
                && (runStateAtLeast(c, STOP)
                    || firstTask != null
                    || workQueue.isEmpty()))
                return false;
					
					// 如果线程状态没有问题，在判断线程个数
            for (;;) {
                if (workerCountOf(c)
                    >= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
                    return false;
                // 为了避免多线程并发，导致破坏设置的核心参数
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateAtLeast(c, SHUTDOWN))
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }
	
		// 创建工作线程，启动工作线程
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null; // Worker对象就是你的工作线程
        try {
        	//创建工作线程，并将任务交给Worker对象
            w = new Worker(firstTask);
            // 直接将new Worker对象时构建的Thread对象拿到
            final Thread t = w.thread;
            // 判断使用线程池的用户，指定的线程工厂构建的thread不是null
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int c = ctl.get();

                    if (isRunning(c) ||
                        (runStateLessThan(c, STOP) && firstTask == null)) {
                        if (t.getState() != Thread.State.NEW)
                            throw new IllegalThreadStateException();
                        // 加锁的原因是要对HashSet操作，HashSet不是线程安全的，不加锁不安全，
                        // 将工作线程添加到works，works是HashSet对象
                        workers.add(w);
                        workerAdded = true;
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

工作队列Worker

线程池里面的工作线程就是Worker对象，查看一下Worker里面做了什么事情。

	// Worker是一个工作线程，同时也会存储一个任务（只存储第一个任务）
    private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        
        @SuppressWarnings("serial")
        final Thread thread;
        
        @SuppressWarnings("serial")
        Runnable firstTask;
  
        Worker(Runnable firstTask) {
        	// 任务构建
            this.firstTask = firstTask;
            // 线程构建
            this.thread = getThreadFactory().newThread(this);
        }
			
		// addWorker中执行thread.start方法后，执行的是Worker对象中的run方法
        public void run() {
            runWorker(this);
        }
    }

AQS是JUC包下的一个并发基类，很多同步内容都是基于AQS实现的，比如：

• ReentrantLock
• ReentrantReadWriteLock
• CountDownLatch
• Semaphore
• 线程池中的Worker对象也是基于AQS做了一个实现.

Worker继承AQS干嘛？
Worker继承AQS后，可以使用CAS修改属性state，state算是一个标记位。
在shutdown状态下，空闲的线程要执行interrupt中断，正在工作状态的线程不能执行interrrupt。
工作线程执行任务之前，会先执行lock方法（将state从0改为1），正在工作的线程，state为1。
在中断线程之前，判断每一个线程的state，如果为0，直接interrupt，如果为1，什么也不干。

执行/拉取任务流程

• 执行任务
  执行任务就是启动工作线程之后，执行了Worker对象的run方法，在run方法里面执行了runWorker方法。

    final void runWorker(Worker w) {
    	// 拿到工作线程中的Thread
        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();
				// 判断线程池状态是不是stop
				// 如果是stop，强制中断当前线程
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                    
                try {
                	// 钩子函数
                    beforeExecute(wt, task);
                    try {
                    	// 执行任务
                        task.run();
                        afterExecute(task, null);
                    } catch (Throwable ex) {
                    	// 钩子函数
                        afterExecute(task, ex);
                        throw ex;
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

• 拉取任务
  工作线程执行完自带的任务后，会直接基于getTask方法从阻塞队列中尝试拉取任务

// 线程正常的生命结束，就是run方法执行完毕
 private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            int c = ctl.get();

            // 判断线程池工作状态，如果为stop，或者为shutdown并且工作队列任务都处理完毕，
            if (runStateAtLeast(c, SHUTDOWN)
                && (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
                // 工作线程个数 - 1，结束当前线程
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            // 核心线程执行take，非核心线程执行poll（poll方法拉取最大空闲时间）
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
	
            try {
                Runnable r = timed ?
                	// poll方法拉取阻塞队列任务，指定keepAliveTime
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    // take方法，死等任务，直到中断 
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

线程池关闭

shutdown方法：

• 将线程池状态修改为shutdown
• 将空闲的工作线程直接中断
• 再确认工作队列中的任务全部处理完，并且工作线程个数为0，自动改为tidying状态
• 在tidying状态下，执行terminated方法，变为terminated状态
• 线程池结束

shutdwonNow方法：

• 将线程池状态改为stop
• 将所有的工作线程直接中断
• 在工作线程个数为0，自动改为tidying状态
• 在tidying状态下，执行terminated方法，变为terminated状态
• 线程池结束

// 优雅地关闭线程池
public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(SHUTDOWN);
            interruptIdleWorkers();
            onShutdown(); 
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
    }

在工作中，核心线程数，最大线程数，空闲时间怎么设置？任务队列怎么设置比较好？
如果为了充分的发挥硬件的性能，一般只考虑三个参数：

• 核心线程数：最终要的属性，根据业务类型判断设置多少合适
  • CPU密集型任务：线程一直在干活，不希望cpu做上下文切换
  • IO密集型任务：因为线程干一会，歇一会
  • 混合型任务：偶尔要求cpu一直调度，偶尔不干活，可以切换
  • 想要设置号核心线程数，去充分发挥服务器的性能，需要动态地调试和压测。为了避免调试参数时，反复重启，成本太高，可以设置动态线程池，线程池提供了set方法设置核心参数，get方法查看核心参数。可以在压测时，根据cpu使用情况来调整核心线程个数
• 工作队列长度：根据服务器的内存使用情况来调试，同时也要查看JVM的堆内存大小
• 拒绝策略：根据任务来决定，如果任务就是写个日志啥的，就直接扔了，如果任务时必须要执行的，那就重试，或者存储到数据库，后期统一做补偿操作。