线程池源码解读以及相关面试题_38 线程池源码面试题-优快云博客

本文链接：https://blog.youkuaiyun.com/JMU_software19/article/details/121899467

本文深入探讨了Java线程池的工作原理，包括ThreadPoolExecutor的核心属性、构造方法、工作流程，以及不同类型的线程池如newFixedThreadPool、newCachedThreadPool和newSingleThreadExecutor。线程池通过复用线程和管理任务队列，提高了系统效率并避免了频繁创建线程的开销。同时，文章提到了线程池的关闭策略和初始化线程数的选择，以及四种拒绝策略。通过对线程池的深入理解，有助于优化并发性能并避免资源耗尽的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

线程池整体解读

核心源码解读

ThreadPoolExecutor的属性

newSingleThreadExecutor

内部类Worker

Worker类的run方法

Worker类中的getTask方法

ThreadPoolExecutor的execute方法

线程池整体解读

线程池是一个可以自动创建并且维护相关线程的一个类，它还能接收任务，将任务分配给自己内部的线程进行执行。它解决了线程重复创建耗时大的问题，实现了线程的复用。其核心组件有四个，分别是线程池管理器（ThreadPool）：用于创建并管理线程池，包括创建线程池，销毁线程池，添加新任务；工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等。任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。线程池还有5种状态，这几种状态的含义是：

RUNNING：接受新任务，也能处理阻塞队列里的任务。
SHUTDOWN：不接受新任务，但是处理阻塞队列里的任务。
STOP：不接受新任务，不处理阻塞队列里的任务，中断处理过程中的任务。
TIDYING：当所有的任务都执行完了，当前线程池已经没有工作线程，这时线程池将会转换为TIDYING状态，并且将要调用terminated方法。
TERMINATED: terminated方法调用完成。

核心源码解读

主要解读的几个核心源码：ThreadPoolExecutor的属性以及内部类与相关方法内部类workers的核心方法。

ThreadPoolExecutor的属性

这里面有两个属性，一个是容量，一个是状态，容量和状态用COUNT_BITS进行位移运算，使得状态只在一个int的前三位表示，容量只在int的后29位表示。然后再使用一个原子整数ctl来储存这两个信息。

这种操作在源码里面很常见，好处就是对这两个状态进行修改的时候不需要两次CAS操作，使用一次CAS然后再进行位运算操作就可以了。

然后是BlockingQueue阻塞队列，用于存放积压任务的阻塞队列，当任务大于当前线程数的时候，任务会被放进阻塞队列，阻塞队列也会有大小，如果阻塞放满了，队列就不会再放任务了，为了应对这个多余的任务，线程池会有四种拒绝策略，这个后面再说。

下面一个是一个可重入的锁ReentrantLock，线程池对线程的操作需要用到同步，所以这里需要一个锁。

接下来是一个HashSet集合，里面装了Worker类，这个Worker类继承了Thread类，可以充当线程使用。

然后是一个条件锁，由主锁mainLock创建的一个条件，用于termination调用时的线程同步

两个成员属性，分别表示线程池最多有多少个活跃线程，和线程池总共处理了多少任务。

一个volatile修饰的ThreadFactory 接口，用户可以自定义创建工作线程的工厂

拒绝策略，上文提到的拒绝策略在这里，这里有一个RejectedExecutionHandler接口，接口内部只有一个方法

用户可以自定义实现拒绝策略。如果线程到达 maximumPoolSize 仍然有新任务这时会执行拒绝策略。拒绝策略 jdk 提供了 4 种实现，其它著名框架也提供了实现 AbortPolicy

让调用者抛出 RejectedExecutionException 异常，这是默认策略
CallerRunsPolicy 让调用者运行任务
DiscardPolicy 放弃本次任务
DiscardOldestPolicy 放弃队列中最早的任务，本任务取而代之
Dubbo 的实现，在抛出 RejectedExecutionException 异常之前会记录日志，并 dump 线程栈信息，方便定位问题
Netty 的实现，是创建一个新线程来执行任务 ActiveMQ 的实现，带超时等待（60s）尝试放入队列，类似我们之前自定义的拒绝策略 PinPoint 的实现，它使用了一个拒绝策略链，会逐一尝试策略链中每种拒绝策略

工作线程空闲时，保持的存活时间

boolean类型，是否需要保持核心工作线程始终保持活跃状态。

一个是核心线程数，一个是最大线程数，核心线程数代表的是这个线程池的最大正常工作线程数，然后最大线程数指的是，当线程池的线程数已经达到了核心线程数的时候，如果任务还有很多，这个时候会产生救急线程，核心线程数加上救急线程数就组成了最大线程数。

线程池的构造方法

public ThreadPoolExecutor(int corePoolSize,
 int maximumPoolSize,
 long keepAliveTime,
 TimeUnit unit,
 BlockingQueue<Runnable> workQueue,
 ThreadFactory threadFactory,
RejectedExecutionHandler handler)

线程池的工作流程

线程池中刚开始没有线程，当一个任务提交给线程池后，线程池会创建一个新线程来执行任务。
当线程数达到 corePoolSize 并没有线程空闲，这时再加入任务，新加的任务会被加入workQueue 队列排队，直到有空闲的线程。
如果队列选择了有界队列，那么任务超过了队列大小时，会创建 maximumPoolSize - corePoolSize 数目的线程来救急。
如果线程到达 maximumPoolSize 仍然有新任务这时会执行拒绝策略。
当高峰过去后，超过corePoolSize 的救急线程如果一段时间没有任务做，需要结束节省资源，这个时间由 keepAliveTime 和 unit 来控制。

不同的线程池

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
 return new ThreadPoolExecutor(nThreads, nThreads,
 0L, TimeUnit.MILLISECONDS,
 new LinkedBlockingQueue<Runnable>());
}

特点

核心线程数 == 最大线程数（没有救急线程被创建），因此也无需超时时间
阻塞队列是无界的，可以放任意数量的任务
适用于任务量已知，相对耗时的任务

newCachedThreadPool

public static ExecutorService newCachedThreadPool() {
 return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
 60L, TimeUnit.SECONDS,
 new SynchronousQueue<Runnable>());
}

特点

核心线程数是 0，最大线程数是 Integer.MAX_VALUE，救急线程的空闲生存时间是 60s，意味着
- 全部都是救急线程（60s 后可以回收）
- 救急线程可以无限创建
队列采用了 SynchronousQueue 实现特点是，它没有容量，没有线程来取是放不进去的（一手交钱、一手交货）
整个线程池表现为线程数会根据任务量不断增长，没有上限，当任务执行完毕，空闲 1分钟后释放线程。适合任务数比较密集，但每个任务执行时间较短的情况

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
 return new FinalizableDelegatedExecutorService
 (new ThreadPoolExecutor(1, 1,
 0L, TimeUnit.MILLISECONDS,
 new LinkedBlockingQueue<Runnable>()));
}

使用场景：

希望多个任务排队执行。线程数固定为 1，任务数多于 1 时，会放入无界队列排队。任务执行完毕，这唯一的线程也不会被释放。

区别：

自己创建一个单线程串行执行任务，如果任务执行失败而终止那么没有任何补救措施，而线程池还会新建一个线程，保证池的正常工作
Executors.newSingleThreadExecutor() 线程个数始终为1，不能修改
- FinalizableDelegatedExecutorService 应用的是装饰器模式，只对外暴露了 ExecutorService 接口，因此不能调用 ThreadPoolExecutor 中特有的方法
Executors.newFixedThreadPool(1) 初始时为1，以后还可以修改
- 对外暴露的是 ThreadPoolExecutor 对象，可以强转后调用 setCorePoolSize 等方法进行修改

内部类Worker

 private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        /**
         * This class will never be serialized, but we provide a
         * serialVersionUID to suppress a javac warning.
         */
        private static final long serialVersionUID = 6138294804551838833L;

        /** Thread this worker is running in.  Null if factory fails. */
        final Thread thread;
        /** Initial task to run.  Possibly null. */
        Runnable firstTask;
        /** Per-thread task counter */
        volatile long completedTasks;

        /**
         * Creates with given first task and thread from ThreadFactory.
         * @param firstTask the first task (null if none)
         */
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

        /** Delegates main run loop to outer runWorker  */
        public void run() {
            runWorker(this);
        }

        // Lock methods
        //
        // The value 0 represents the unlocked state.
        // The value 1 represents the locked state.

        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) {
                }
            }
        }
    }

它继承了AQS，说明Worker内部存在同步的需求，实现了Runnable接口说明本身可以是一个异步的任务调度者。

Worker类的run方法

其中最主要的方法还是run方法，也就是runWorker方法，该方法当Worker启动的时候便会调用，

主要实现功能就是，将该worker的任务执行，并且获得新的任务执行。

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            //如果当前任务执行完毕，则会去获得新的任务，如果没有得到新的任务，那么结束循环，并                          
            //且执行下面的finally代码块中的销毁线程操作
            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
                // 判断当前线程池的状态以及线程中断状态，若当前线程池状态>=stop（非running，
                // shutdown状态),则对当前线程调用中断，当线程正在运行的时候，对线程调用中断
                // 只是标记将要中断的状态，并不会立即中断
                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方法，意思是是在当前线程执行，并非新的线程
                        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);
        }
    }

Worker类中的getTask方法

主要功能是为线程获得工作任务

private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            //获得当前的状态
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            //如果当前线程池已经是STOP,TIDYING,TERMINDATED,或者是SHUTDOWN且工作队列为空，
            //那么返回null，表明没有任务可以获取
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
            //获得当前活跃worker数
            int wc = workerCountOf(c);

            // Are workers subject to culling?
            //如果如果当前工作线程数超过了最大线程数，或者达到了核心线程的回收条件，则返回null
            //表示需要回收当前线程
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }
            //都判断通过，表示还有任务需要当前线程执行，那么从workQueue中take任务
            try {
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

ThreadPoolExecutor的execute方法

execute中文意思是执行，也就是线程池执行任务的方法，它接受一个可执行的Runnable任务参数，当一个任务交给线程池的时候，如果线程池此时没有线程，那么线程池可能会使用已有的线程进行处理。当然如果线程池的线程都在执行任务，那么它首先看能不能创建救急线程，如果不能创建救急线程，那这个任务可能会被放入队列缓存，如果队列满了的话，那么将会出发拒绝机制。

 public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        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);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }