Java线程池

为什么需要线程池呢？

想象这么一个场景：

在学校附近新开了一家快递店，老板很精明，想到一个与众不同的办法来经营。店里没有雇人，而是每次有业务来

了，就现场找一名同学过来把快递送了，然后解雇同学。这个类比我们平时来一个任务，起一个线程进行处理的模

式。

很快老板发现问题来了，每次招聘 + 解雇同学的成本还是非常高的。老板还是很善于变通的，知道了为什么大家都要

雇人了，所以指定了一个指标，公司业务人员会扩张到 3 个人，但还是随着业务逐步雇人。于是再有业务来了，老板

就看，如果现在公司还没 3 个人，就雇一个人去送快递，否则只是把业务放到一个本本上，等着 3 个快递人员空闲

的时候去处理。这个就是我们要带出的线程池的模式。

线程池最大的好处就是减少每次启动、销毁线程的损耗

实现一个线程池：

/*线程池：
 * 首先创建一个阻塞堆，阻塞堆里面放置的是Runnable对象，创建一个List，list里面放置的是线程对象
 *通过Worker里面的run方法不断的循环执行线程，线程读取的的是阻塞堆里面的Runnable对象，其中还要加入判断
 * 当线程池小于规定的线程数量的时候，这是是需要创建新的线程的同时开启线程。要是到达了规定的线程数量
 * 这时候直接把Runnable对象扔进阻塞堆中待取，取的时候直接取出，放入线程池中即可
 * 为什么不会出现线程安全问题：
 * 因为这里读取的线程是通过while循环读取的，只要while语句没有结束,就不会有下一个线程进行。
 *  */

下面直接看代码，代码中有详细的解释

public class TestDemo23_2 {
    //Worker类，里面包含了阻塞队列，线程id，并且有这两的构造方法

    static class Worker extends Thread {
        private BlockingDeque<Runnable> queue = new LinkedBlockingDeque<>();
        private int id;

        public Worker(BlockingDeque<Runnable> queue, int id) {
            this.queue = queue;
            this.id = id;
        }

        @Override
        public void run() {
            try {
                //下面的线程池每当list.size() < max成立的时候，就会新建一个线程
                //并且启动该线程，这个类里面的线程一经启动就不会自动停下来，知道等到
                //interrupt任务位置，只要没有被强行停止，就不断的扫描queue，
                while (!Thread.currentThread().isInterrupted()) {
                    //获取queue中的Runnable对象
                    Runnable worker = queue.take();
                    System.out.println("thread " + id + " running");
                    //执行Runnable对象
                    worker.run();
                }
            } catch (InterruptedException e) {
                System.out.println("线程终止");
            }
        }
    }

    static class MyThreadPool {
        //创建一个阻塞队列，阻塞队列里放置的是需要通过线程去运行的Runnable对象
        private BlockingDeque<Runnable> queue = new LinkedBlockingDeque<>();
        //创建一个顺序表表示线程池，顾名思义是放线程的。
        List<Worker> list = new ArrayList<>();
        //定义一个常量，表示线程池中最多放置多少条线程
        private static final int max = 10;

        //execute函数，形参里面是一个Runnable对象
        public void execute(Runnable command) throws InterruptedException {
            //每次调用该方法时，先判定线程池是否已满，没满的话就执行下面的内容
            //县城建一个线程对象worker，然后启动它，注意，启动了之后他就一直在跑
            //第一次进入该函数的时候list.size()为0；所以线程编号为0；
            //最后把这个线程加入到线程池中，此时线程池就多了一条线程
            if (list.size() < max) {
                Worker worker = new Worker(queue, list.size());
                worker.start();
                list.add(worker);
            }
            //上面是创建线程，和下面这部没有关系，无论如何command都必须放入queue中
            //因为只有被放入queue中才能被线程执行
            queue.put(command);
        }

        //终止掉所有线程
        public void shutdown() throws InterruptedException {
            //遍历每个线程，并且调用interr方法使其停止
            for (Worker list : list
            ) {
                list.interrupt();
            }
            //等待每个线程都结束
            for (Worker list : list) {
                list.join();
            }
        }
    }

    //实现一个Command类，因为每次创建任务的时候必须要有Runnable对象才行
    //通过实现这个类，然后把这个类放入到线程中执行：每次被实现的对象都是我们最终的
    //目的，什么意思呢，就是说这里面才是我们想要线程执行的东西
    static class Command implements Runnable {
        private int id;

        public Command(int id) {
            this.id = id;
        }

        @Override
        public void run() {
            System.out.println("正在执行任务：" + id);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //先创建一个线程池，
        MyThreadPool myThreadPool = new MyThreadPool();
        for (int i = 0; i < 1000; i++) {
            //通过for循环把new的command变量加入的queue中，然后通过线程调用
            myThreadPool.execute(new Command(i));
        }
        Thread.sleep(10);
        //中段所有线程
        myThreadPool.shutdown();
        System.out.println("线程被毁");
    }

}