面试官：线程池是如何做到线程复用的？有了解过吗？(面试官提问：线程池如何实现线程复用？你了解吗？)

一、线程池的概念

在Java中，线程池是一种用于管理线程的工具，它允许我们重用已经创建的线程，而不是每次需要执行任务时都创建新线程。这样可以缩减线程创建和销毁的开销，尽大概缩减损耗系统的性能。

二、线程池的工作原理

线程池的工作原理关键基于线程复用和任务队列。当我们向线程池提交一个任务时，线程池会按照一定的策略来处理这个任务。以下是线程池的基本工作流程：

• 1. 判断线程池中的线程数量是否小于核心线程数（corePoolSize）。
• 2. 如果小于核心线程数，则创建一个新的线程来执行任务。
• 3. 如果大于等于核心线程数，但任务队列未满，则将任务放入任务队列。
• 4. 如果任务队列已满，判断线程池中的线程数量是否小于最大线程数（maximumPoolSize）。
• 5. 如果小于最大线程数，则创建一个新的线程来执行任务。
• 6. 如果大于等于最大线程数，则拒绝执行该任务，抛出异常。

三、线程池的线程复用机制

线程池实现线程复用的关键在于线程池内部维护了一个线程队列，这个队列中的线程在执行完任务后并不会立即销毁，而是会等待下一次任务的到来。以下是线程复用的具体实现：

1. 线程创建

当线程池接收到一个任务时，会结合当前线程池的状态来决定是否创建新线程。创建线程的代码如下：

        private final ReentrantLock mainLock = new ReentrantLock();
        private final HashSet workers = new HashSet<>();
        private final LinkedBlockingQueue workQueue;
        private final ThreadFactory threadFactory;
        private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
        private final int corePoolSize;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final ThreadFactory threadFactory;
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this.mainLock;
        private final Condition condition = mainLock.newCondition();
        private final AtomicBoolean allowCoreThreadTimeOut = new AtomicBoolean(false);
        private final boolean prestartCoreThread;
        private final int maximumPoolSize;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private final ThreadFactory threadFactory;
        private final BlockingQueue workQueue;
        private final ReentrantLock mainLock = this
本文由IT视界版权所有,禁止未经同意的情况下转发