ThreadPoolExcuter源码阅读-CSDN博客

本文链接：https://blog.csdn.net/weixin_39808420/article/details/132043908

线程池的基本参数

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), handler);
}

主要是
核心线程数：可以一直存活的工作线程
最大线程数：当线程队列满的时候增加线程数，超过核心线程数的新增的为非核心线程，超过固定时长没任务执行就进行销毁
非核心线程的空闲时长：非核心线程超过多久进行销毁
工作队列：当核心线程都在工作的时候，新来的任务放入工作队列，等待执行
拒绝策略：核心队列满了，最大线程数也达到了，新来的任务执行拒绝策略
还有可以自定义ThreadFactory，控制线程的创建，这里没特殊需求，使用的是默认的线程工厂

线程池的拒绝策略

可以自定义线程的拒绝策略，默认提供拒绝策略主要分为四种

CallerRunsPolicy让主线程进行执行
AbortPolicy拒绝任务，抛出异常RejectedExecutionException
DiscardPolicy 直接丢掉这个任务
DiscardOldestPolicy 直接丢掉最早的任务

一般情况下可以满足使用，如有特殊情况，可以进行自定义拒绝策略，实现接口RejectedExecutionHandler

线程池执行过程

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
    	// 这里的c 是定义的AtomicInteger的一个成员变量，使用29位来表示线程数，剩下3位表示线程池的
    	//状态，所以最大支持的线程数(2^29)-1
        int c = ctl.get();
    	// 如果当前线程数小于核心线程数
        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);
            // 这里判断如果工作线程数为0（因为核心线程数允许为0），是要添加一个线程的，
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //如果没添加到队列，应该队列满了，直接添加非核心线程，如果添加失败走拒绝策略
        else if (!addWorker(command, false))
            reject(command);
    }

线程池的几种状态
RUNNING: 接受新任务并处理排队的任务
SHUTDOWN: 不接受新任务，但是处理队列里面的人物
STOP: 不接受新任务，不处理排队的任务，并中断正在进行的任务
TIDYING: 所有任务都已终止，workerCount为零，转换到状态TIDYING的线程将运行terminated（）
TERMINATED： terminated（）钩子方法完成时

分析下addWorker方法做了什么

    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (int c = ctl.get();;) {
            // Check if queue empty only if necessary.
            if (runStateAtLeast(c, SHUTDOWN)
                && (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;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            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();
                        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;
    }

简单总结下，判断下添加工作线程，线程池是不是运行状态，是不是达到了设置的核心线程和最大线程限制，不符合条件的直接返回添加失败，符合条件的进行添加，如果添加成功，跳出循环，没添加成功就继续循环cas添加。
检查通过并且增加数量之后，开始实际创建Worker，然后归入workers进行管理，处理完之后调用线程的start方法，线程的start方法最后会调用jni新开线程，执行到run()方法，那么就去看下run方法的执行逻辑，run里面比较简单，直接调用的 runWorker(this);

runWoker 是怎么执行的

    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            // 获取task，如果fisrtTask为空，就执行getTask进行获取
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                // 判断下线程池状态和线程状态，是不是进行了打断操作
                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);
        }
    }

总结下就是循环获取任务进行执行，执行判断下线程池的状态和线程的状态，然后可以执行下扩展的任务执行前后需要执行的操作，发生异常执行worker退出操作

核心线程和非核心线程是怎么区分管理的

这个主要就在getTask方法的管理了，task究竟是怎么进行获取的呢

private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?
    	// 死循环获取任务
        for (;;) {
            int c = ctl.get();

            // Check if queue empty only if necessary.
            if (runStateAtLeast(c, SHUTDOWN)
                && (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            // Are workers subject to culling?
            // 判断是不是有超时时间，核心线程是不是有超时时间
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

            // 判断线程是不是具备销毁条件，超过最大线程数，或者具备超时时间并且超过的
            // 减去线程数
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
                // 这里就是区分是不是需要超时时间的，主要区分于核心线程和非核心线程，
                // 常驻的线程直接就是take（）死等
                // 需要具备超时时间的线程就使用workQueue的poll来设置超时时间，如果超时了
                // 下次循环判断出来就执行上面的减去线程的操作了
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }