线程池的前世今生

CPU线程争抢

线程池是池化技术的一种实现，用户对线程做统一的管理，通过统一的管理来降低资源的消耗与提高资源的利用率。

本文将通过一个小故事来回顾一下java线程池的前世与今生。

P1:上古时代

对于早期的计算机语言，设计的基本思路都是通过一个Main函数启动，开启主进程。之后在这个主进程中，再开启一个个工作线程。如果主进程挂掉，那么整个程序也就终止了。

故事

张某三去饭店吃饭，需要凭票入场。

张三想进去吃饭，门童会在门口用石板刻上张某三，把这块牌子给张某三。

到饭点饭店开使营业了，只要有拿到票，那就可以进去了，进去的时候门童就把票根砸碎。

这时票是一次性的，用完就没了。这家饭店就属于邀请制，给你发一张券你能来一次。

线程的上古使用

从远古的jdk1.0开始，就有Thread类与Runnable接口。Thread类也是实现了Runnable接口。所以无论是通过继承一个Thread类重写run方法，还是实现Runnable接口重写run方法后，再丢入Thread构造器本质上都一样，都是将这个任务赋值给Thread类中的类型为Runnable的target属性。

Thread构造方法调用init方法

创建一个Card类，就相当于是故事中的门票。后续故事中也同样会使用。在实际工作中，可以理解为一些特别耗内存的大对象、或者耗费时间的io操作或者网络请求。

@Data
class  Card {
    String name;
}

通过Main方法直接执行。其中Card对象，Thread对象都被重复创建了多次。所以在上古时代，这种使用线程的方法是非常麻瓜的。

public static void main(String[] args) throws InterruptedException {

        Demo demo = new Demo();
        demo.old();// 上古时代
//      demo.old2();//古代
//      demo.old3();//近代
        System.out.println("demo -> end");
    }

    public void old() throws InterruptedException {
        AtomicInteger times = new AtomicInteger(0);
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Card card = new Card();
                card.setName("张某三特邀贵宾" + times.incrementAndGet());
                System.out.println(Thread.currentThread().getName()+card.getName());
            }).start();
        }
        Thread.sleep(100);
        System.out.println("门票创建"+times.get()+"次");
    }

从打印的结果也可以看到，每一次都是一个新的线程在执行任务。

demo1执行结果

P2:古代

故事2.0

张某三又去这家饭店吃饭，同样需要凭票入场。

门童在门口用石板刻上了店铺高级vip，把这块牌给到了张某三。

这样一来，只要饭店不倒闭，张某三就能凭票进场。

等饭店到了饭点开始营业，张某三凭票进场，吃完之后又把票塞进编织袋好好保存，放在家里贡了起来。

这块号牌此时就类似于丹书铁券、免死金牌，父传子子传孙，出入这种高级场所有牌就行，属于高级会员制。

线程的古代使用方式

public void old2() throws InterruptedException {
        AtomicInteger times = new AtomicInteger(0);
        Card card = new Card();
        card.setName("张某三VIP"+times.incrementAndGet());
        Runnable eat = () -> System.out.println(Thread.currentThread().getName()+card.getName());
        LinkedBlockingDeque eats = new LinkedBlockingDeque<>();
        for (int i = 0; i< 10; i++) {
            eats.add(eat);
        }

        new Thread(()->{
            //线程死循环, 模拟线程不退出, 一直会尝试去获取任务
            AtomicInteger eatTimes = new AtomicInteger(0);
            for (;;) {
                do {
                    try {
                        eats.take().run();
                        Thread.sleep(3);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } while (eatTimes.incrementAndGet() < 10);
                break;
            }
        }).start();

        Thread.sleep(100);
        System.out.println("门票创建"+times.get()+"次");
    }

从执行结果可以看到。耗时的Card只被新建了一次，Thread线程也只被创建了一次。说明已经共用了线程与对象。从日志看到，也确实只有一个线程Thread-0执行任务。

方案就是一直让线程执行死循环等待，从任务队列中取任务。更高级的操作应该是让线程在没有任务时休眠，而不是一直争抢CPU时间片，当然这些功能在近代jdk1.5中已经实现。

古代线程使用方法

P3:近代

故事3.0

张某三又去这家饭店吃饭，需要凭手牌入场。

门童给你一块手牌，手牌上只写了39号。

饭店开始营业之后，张某三吃完饭叼着牙签出来，看到李某四饿的骨瘦嶙峋，饿的好几天没吃饭了。

于是张某三一发善心，转手100块钱就把这个手牌卖给了李某四。

李某四拿着手牌，门童验明真伪，确实是他们饭店发出去的手牌，也就让李某四进去了。（李某四吃完饭，没有钱付餐费，这个时候饭店把李某四catch住，把手牌也顺便给销毁了，这部分就属于线程异常时的处理，有机会另开一篇聊聊）

近代使用方式

单线程的复用并不优雅，对于内部的执行逻辑，管理并不方便。所以在jdk1.5之后，JDK提供了ExecutorService类，实现了线程池的功能。当然我们用的最多，问的最多的还是ThreadPoolExecutor。

public void old3() throws InterruptedException {
        ExecutorService shop = Executors.newSingleThreadExecutor();
        AtomicInteger times = new AtomicInteger(0);
        Card card = new Card();
        card.setName("张某三手牌"+times.incrementAndGet());
        Runnable eat = () -> System.out.println(Thread.currentThread().getName()+card.getName());
        for (int i = 0; i < 10 ; i++) {
            shop.execute(eat);
        }
        Thread.sleep(100);
        System.out.println("=======张某三完事=========");
        // 转卖手牌
        card.setName(card.getName().replace("张某三", "李某四"));

        for (int i = 0; i < 10 ; i++) {
            shop.execute(eat);
        }
        Thread.sleep(100);
        System.out.println("门票创建"+times.get()+"次");
    }

创建了一个单线程的线程池，因此只有一个线程会执行任务。通过线程的命名方式也被改写为pool name+thread name。

耗时的Card只被创建了一次，Thread的创建被封装进了线程池中，并且同一个线程可以执行多种任务。另外，线程池也提供了比较丰富的API对线程池的状态做管理。

近代线程池的使用

P4:现代

最近几年，慢慢在网上可以看到关于线程监控方面的文章。说明当前对线程池的需求也不仅仅局限在用这一方面。对线程的管理，或者是对线程的精细化管理将成为重点。

不过在国内看到的文章大都是基于美团技术文章的实现。更详细的可以看写美团的文章，也可以在网上搜索下相关的博文。

https://tech.meituan.com/2020/04/02/java-pooling-pratice-in-meituan.html