手写ThreadPoolExecutor线程池

很多人不推荐造轮子，我偏不。我造轮子又不是为了上生产环境，而是为了加深理解，有何不可？私以为造轮子几乎是最好的学习方式，甚至没有之一。因为造轮子需要至少做足以下两点：

• 了解设计思想（设计层面）
• 大略看过源码（代码层面）

不了解设计，就无法把握整体。没看过代码，就无法完善细节。

另外，从创作者的角度来说，直接分析源码有时太困难了，代码太多，抽象层次太深。如果可以通过造轮子，把抽象层次减少一些，采用平铺直叙的方式呈现，那么读者理解起来也就更容易些。

既然造轮子这么好，那就，拿来吧你。今天带大家造一个线程池。

线程池设计思想

池化技术

大家多少听过所谓的“池化技术”，比如数据库连接池、常量池、线程池、对象池等等。池化技术是计算机世界里比较常用的、行之有效的优化手段。那么我想问你，线程池中的“池”，到底指代什么？

抛开无足轻重的小虾米，线程池中最主要的就两个：我们向Executor提交的任务、Executor自己维护的Thread。其中，线程“池”显然指代的是Thread的集合。

但和数据库连接池等一般的池化技术不同的是，ThreadPool的作用不单单是“池化”，它更重要的职责其实是“做功”，也即是执行任务。举个例子，平时我们使用数据库连接池，其实都是从池中取出一个Connection，执行完SQL后会调用重写过的close()归还Connection。但你可曾见过有人向ThreadPool讨要Thread的？它会给你吗？ThreadPool的做法是：

想要从池中拿Thread？没门儿！你不知道自己多线程知识多菜啊？小心玩火自焚。要执行任务的话，你自己把Task丢进来，哥罩着你。

也就是说，ThreadPool从一开始就没想过让你们把Thread拿走！但你们又要返回结果咋整？我返回一个FutureTask，需要结果的话，自己FutureTask#get()。但主动权还是在ThreadPool这，能不能拿到结果、是否要阻塞都是它说了算！

大部分人觉得线程池难，并非搞不清楚线程“池”，而是不了解它是如何“做功”的，也就是说：线程池是如何执行任务的呢？这就涉及到线程池和一般池化技术最大的不同：内化执行操作，而且是通过生产消费的模式执行任务。

生产消费模型

如果往线程池不断提交任务，大致会经历4个阶段：

• 核心线程处理任务
• 任务进入任务队列等待
• 非核心线程处理任务
• 拒绝策略

特别是第二个阶段，来不及处理的任务会被暂存入workQueue（任务队列），于是典型的生产消费模型就出现了。

调用者投递Task ====> ThreadPool.workQueue ====> workerThread阻塞获取Task执行

几个重要概念

线程池如何复用线程？

有时候，要解决一个问题，从反方向入手可能更简单写。我们暂且先不管如何复用线程，我就问大家：如何回收/销毁线程？（知道线程什么情况会被销毁，那么只要避免销毁，也就可以复用）

“线程”这个词，其实有两个层次的指代：Thread对象、JVM线程资源（本质还是操作系统线程）。Thread对象与线程资源之间是绑定关系，一个线程资源被分配后，会找到Thread#run()作为代码的执行入口。

线程什么时候销毁呢？正常来说，new Thread(tartget).start()后，操作系统就会分配线程资源。等到线程执行完Thread#run()中的代码，就会自然消亡。至于Thread对象，如果没有引用，也会被GC回收。

看到这，我想大家应该明白了：只要任务永远不结束，线程就永远死不了。任务如何才能永远不结束呀？要么循环做任务、要么阻塞。

线程池本质也是Thread，只是单体和集合的区别。既然Thread“跑完任务就销毁”的特性是天生的、注定的，线程池也无法改变这一点。所以，线程池要想让内部线程一直存活着，就要keeps threads busy working，也就是让它们一直干活。实在没活干怎么办？那就阻塞着呗（可以用阻塞队列）！总之，不能让你“执行完毕”，否则就销毁了。

如何保证只销毁“非核心线程”

大家都听过一些八股文的口诀，比如“在空闲时间，如果非核心线程空闲超过keepAliveTime就会被回收”，这是怎么实现的呢？

首先，有一个常见的误区是，很多人以为线程池创建线程时会给每一个Thread做标记，比如给核心线程标记为coreThread，非核心线程标记为nonCoreThread，然后空闲时间回收nonCoreThread。

然而JDK的Doug Lea可不这么想，人家采用的方案更加简单粗暴：

• 当前线程数 <= corePoolSize，那么所有线程都是核心线程，不回收
• 当前线程数 > corePoolSize，那么适当回收部分线程

看吧，“部分”线程，甚至压根不管你是谁。

OK，罗里吧嗦讲了一大堆，开始coding吧。

山寨线程池Demo

建议大家拷贝代码到本地debug调试，代码已经很精简了，比较容易追踪。

public class ThreadPool {

    private final ReentrantLock mainLock = new ReentrantLock();

    /**
     * 工作线程
     */
    private final List workers = new ArrayList<>();
    /**
     * 任务队列
     */
    private BlockingQueue workQueue;
    /**
     * 核心线程数
     */
    private final int corePoolSize;
    /**
     * 最大线程数
     */
    private final int maximumPoolSize;
    /**
     * 非核心线程最大空闲时间（否则销毁线程）
     */
    private final long keepAliveTime;

    public ThreadPool(int corePoolSize,
                      int maximumPoolSize,
                      long keepAliveTime,
                      TimeUnit timeUnit,
                      BlockingQueue workQueue) {
        this.workQueue = workQueue;
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.keepAliveTime = timeUnit.toNanos(keepAliveTime);
    }

    public void execute(Runnable task) {
        Assert.notNull(task, "task is null");

        // 创建核心线程处理任务
        if (workers.size() < corePoolSize) {
            this.addWorker(task, true);
            return;
        }

        // 尝试加入任务队列
        boolean enqueued = workQueue.offer(task);
        if (enqueued) {
            return;
        }

        // 创建非核心线程处理任务
        if (!this.addWorker(task, false)) {
            // 非核心线程数达到上限，触发拒绝策略
            throw new RuntimeException("拒绝策略");
        }
    }

    private boolean addWorker(Runnable task, boolean core) {
        int wc = workers.size();
        if (wc >= (core ? corePoolSize : maximumPoolSize)) {
            return false;
        }

        boolean workerStarted = false;
        try {
            Worker worker = new Worker(task);
            final Thread thread = worker.getThread();
            if (thread != null) {
                mainLock.lock();
                workers.add(worker);
                thread.start();
                workerStarted = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            mainLock.unlock();
        }

        return workerStarted;
    }

    private void runWorker(Worker worker) {
        Runnable task = worker.getTask();

        try {
            // 循环处理任务
            while (task != null || (task = getTask()) != null) {
                task.run();
                task = null;
            }
        } finally {
            // 从循环退出来，意味着当前线程是非核心线程，而且需要被销毁
            // Java的线程，既可以指代Thread对象，也可以指代JVM线程，一个Thread对象绑定一个JVM线程
            // 因此，线程的销毁分为两个维度：1.把Thread对象从workers移除 2.JVM线程执行完当前任务，会自然销毁
            workers.remove(worker); // TODO 最好加锁
        }
    }


    private Runnable getTask() {
        boolean timedOut = false;

        // 循环获取任务
        for (; ; ) {

            // 是否需要检测超时：当前线程数超过核心线程
            boolean timed = workers.size() > corePoolSize;

            // 需要检测超时 && 已经超时了
            if (timed && timedOut) {
                return null;
            }

            try {
                // 是否需要检测超时
                // 1.需要：poll阻塞获取，等待keepAliveTime，等待结束就返回，不管有没有获取到任务
                // 2.不需要：take持续阻塞，直到获取结果
                Runnable r = timed ?
                        workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                        workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

    @Getter
    @Setter
    private class Worker implements Runnable {
        private Thread thread;
        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
            thread = new Thread(this);
        }

        @Override
        public void run() {
            runWorker(this);
        }
    }

}

代码示意图（虚线框内由Thread异步执行）：

这个图有瑕疵，实际上线程池并不区分coreThread和nonCoreThread，仅看当前线程数是否大于corePoolSize

测试案例

@Slf4j
public class ThreadPoolTest {

    public static void main(String[] args) {

        // 创建线程池，核心线程1，最大线程2
        // 提交4个任务：第1个任务交给核心线程、第2个任务入队、第3个任务交给非核心线程、第4个任务被拒绝
        ThreadPool threadPoolExecutor = new ThreadPool(
                1,
                2,
                1,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1)
        );

        threadPoolExecutor.execute(() -> {
            log.info("{}:执行第1个任务...", Thread.currentThread().getName());
            sleep(10);
        });

        sleep(1);

        threadPoolExecutor.execute(() -> {
            log.info("{}:执行第2个任务...", Thread.currentThread().getName());
            sleep(10);

        });

        sleep(1);

        threadPoolExecutor.execute(() -> {
            log.info("{}:执行第3个任务...", Thread.currentThread().getName());
            sleep(10);
        });

        sleep(1);

        threadPoolExecutor.execute(() -> {
            log.info("{}:执行第4个任务...", Thread.currentThread().getName());
            sleep(10);
        });

        sleep(1);

        log.info("main结束");
    }

    private static void sleep(int seconds) {
        try {
            TimeUnit.SECONDS.sleep(seconds);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

大家可以把测试案例中的线程池换成JDK的ThreadPoolExecutor，执行效果很类似：