【 多线程案列 - 线程池 】

一、什么是线程池

将线程提前创建好，放入到一个特定的池子中，后面使用线程的时候就不需要重新创建，而是直接从该池子中获取，且用完之后又放入该池子.这样不需要频繁地销毁创建线程了.速度就快得多.而这个池子就是 线程池

提问： 为什么线程放入线程池就比从系统中申请释放来的更快呢？

想要解决这个问题，我们就需要认识下用户态和内核态，如下：

可能这样讲还是比较抽象，我们举个例子：

二、标准库中的线程池

Executors 创建线程池的几种方式：

1. newFixedThreadPool: 创建固定线程数的线程池
   (当创建的线程数目超出了固定线程数该怎么办？请参考)
2. newCachedThreadPool: 创建线程数目动态增长的线程池.
3. newSingleThreadExecutor: 创建只包含单个线程的线程池.
4. newScheduledThreadPool: 设定 延迟时间后执行命令，或者定期执行命令. 是进阶版的 Timer.

注意：

1. 返回值类型为 ExecutorService
2. 通过 ExecutorService.submit 可以注册一个任务到线程池中
3. Executors 本质上是 ThreadPoolExecutor 类的封装.ThreadPoolExecutor 提供了更多的可选参数, 可以进一步细化线程池行为的设定

代码示例：

public class ThreadPool {
        //Executors 创建线程池的几种方式
    public static void main(String[] args) {
        // 创建一个固定线程数目的线程池. 参数指定了线程个数
        //ExecutorService pool = Executors.newFixedThreadPool(10);
        //创建一个自动扩容的线程池. 会根据任务量来自动进行扩容
        ExecutorService pool = Executors.newCachedThreadPool();
        // 创建一个只有一个线程的线程池.
        // Executors.newSingleThreadExecutor();
        // 创建一个带有定时器功能的线程池. 类似于 Timer
        // Executors.newScheduledThreadPool();

        for (int i = 0; i < 100; i++) {
            pool.submit(new Runnable() {//通过submit可以注册一个任务到线程池中
                @Override
                public void run() {
                    System.out.println("hello threadpool");
                }
            });
        }
    }
}

提问： 一个程序并发的/多线程的来完成一些任务，若使用线程池，这里的线程数应该设为多少？

其实这里没有标准答案！只能通过性能测试或者其他手段，才能找到合适的值.比如，我写一个服务器程序，通过线程池的方式来处理用户的请求，就可以通过性能测试，构造很多请求发送给服务器，根据实际业务场景来测量出一个合适的值

---

三、自己实现线程池

1. 核心操作为 submit, 将任务加入线程池中
2. 使用 Worker 类描述一个工作线程. 使用 Runnable 描述一个任务.
3. 使用一个 BlockingQueue 组织所有的任务
4. 每个 worker 线程要做的事情: 不停的从 BlockingQueue 中取任务并执行.
5. 指定线程池的最大线程数 maxWorkerCount; 当当前线程数超过这最大值时, 就不新增线程了.

代码示例：

class MyThreadPool {
    // 1. 描述一个任务. 直接使用 Runnable, 不需要额外创建类了.
    // 2. 使用一个数据结构来组织若干个任务.
    private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();

    // 3. 描述一个线程, 工作线程的功能就是从任务队列中取任务并执行.
    static class Worker extends Thread {
        // 一个线程内部并行的执行若干个任务
        // 当前线程池中有若干个 Worker 线程~~ 这些 线程内部 都持有了上述的任务队列.
        private BlockingQueue<Runnable> queue = null;

        public Worker(BlockingQueue<Runnable> queue) {
            this.queue = queue;
        }
        @Override
        public void run() {
            // 就需要能够拿到上面的队列!!
            while (true) {
                try {
                    // 循环的去获取任务队列中的任务.
                    // 这里如果队列为空, 就直接阻塞. 如果队列非空, 就获取到里面的内容~~
                    Runnable runnable = queue.take();
                    // 获取到之后, 就执行任务.
                    runnable.run();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    // 4. 创建一个数据结构来组织若干个线程.
    private List<Thread> workers = new ArrayList<>();

    public MyThreadPool(int n) {
        // 在构造方法中, 创建出若干个线程, 放到上述的数组中.
        for (int i = 0; i < n; i++) {
            Worker worker = new Worker(queue);
            worker.start();
            workers.add(worker);
        }
    }
    // 5. 创建一个方法, 能够允许程序猿来放任务到线程池中.
    public void submit(Runnable runnable) {
        try {
            queue.put(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(10);
        for (int i = 0; i < 100; i++) {
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello threadpool");
                }
            });
        }
    }
}