多线程编程9—

多线程编程9——线程池

一、为什么要引入线程池？

虽然对比进程，线程已经很轻量了，创建销毁调度线程都更高效。但是随着并发程度的提高，我们对于性能要求的标准也越来越高，当我们需要频繁创建销毁调度线程时，就发现线程也没有那么轻量。于是就引入了线程池，来进一步提高效率。

二、线程池的理论知识

事先把需要的线程创建好，放到“线程池”中，后面使用的时候，直接从池里取；用完了，直接放回池中。从池中取和放回池中，这两个操作，比创建销毁线程更高效。

为什么呢？

因为从池中取和放回池中，是程序员自己的代码就可以实现的，想干啥，怎么干，都由程序员自己决定的，是用户态。

而创建和销毁线程，是由操作系统内核完成的，内核只会给我们提供一些API（也就是系统调用），我们只能够通过系统调用，让内核去完成创建或销毁线程，但我们并不清楚内核都要做哪些工作，身上背负着哪些任务，（内核并不是只给一个应用程序服务），什么时候才能帮我们去创建或销毁线程，整个过程是不可控的。

用户态比内核态更高效，所以使用线程池更高效。

三、线程池的使用

Java标准库中，提供了现成的线程池，可以直接使用。

这里使用到了“工厂模式”这种设计模式。

像 newFixedThreadPoll()这样的方法，称为“工厂方法”，提供这个工厂方法的类（Executors），称为“工厂类”。工厂方法一般都是普通的静态方法，使用工厂类的工厂方法，来代替构造方法创建对象。（相当于把new对象的代码，放到工厂方法里了，我们只需要调用工厂方法，就能直接构造出一个对象来）

工厂类Executors 提供的线程池有很多种：

ExecutorService pool1 = Executors.newFixedThreadPool(10); 构造出固定线程数的线程池
ExecutorService pool2 = Executors.newCachedThreadPool(); 线程数量是动态变化的（如果任务多了，就多搞几个线程；如果任务少了，就少搞几个线程）
ExecutorService pool3 = Executors.newSingleThreadExecutor(); 线程池里只有一个线程
ScheduledExecutorService pool4 = Executors.newScheduledThreadPool(10); 类似于定时器，让任务延时执行。

我们用 Executors.newFixedThreadPool(10）来举例。

此处是通过工厂方法创建了一个10个线程的线程池对象（线程池里已经有10个线程了，这些线程都是前台线程），然后我们就可以随时安排这些线程去干活了。

通过线程池提供的 submit方法，可以给线程池提交若干个任务（往线程池的任务队列里放任务）

于是，线程池里的每个线程，就会自己从任务队列中取走一个任务去执行，执行完，再立即去取下一个任务去执行。

代码如下：

public static void main(String[] args) {
        //构造了一个10个线程的线程池
        ExecutorService pool = Executors.newFixedThreadPool(10);
        //通过submit，往线程池的任务队列里放100个任务
        for (int i = 0; i < 100; i++) {
            int n = i;
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    //往任务队列中放的的任务
                    System.out.println("hello "+n);
                }
            });
        }
    }

所以，使用Java线程的线程池时，只要通过submit往线程池的任务队列中指定任务就行啦，是不是非常方便呢。

四、实现一个线程池

实现固定数量线程的线程池

一个线程池里面至少要有2个大的部分

（1）阻塞队列：用来去保存任务

（2）若干个工作线程，每个线程的活：循环（从阻塞队列中取出任务，去执行）

提供一个submit方法，调用submit方法可以往任务队列中放任务。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

class MyThreadPool{
    //任务队列
    private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();
    //线程数
    public MyThreadPool(int n){
        //创建n个线程，每个线程都会不停从任务队列里拿任务去执行
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(()->{
                while(true){
                    try {
                        Runnable runnable = queue.take();
                        runnable.run();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            t.start();
        }
    }
    //往任务队列里放任务
    public void submit(Runnable runnable){
        try {
            queue.put(runnable);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}


public class ThreadDemo8 {
    public static void main(String[] args) {
        MyThreadPool myThreadPool = new MyThreadPool(10);
        for (int i = 0; i < 10; i++) {
            int n = i;
            myThreadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello "+n);
                }
            });
        }
    }
}

五、认识 ThreadPoolExecutor类中构造方法的参数

上面介绍的工厂类Executors提供的这些线程池，本质上都是通过包装 ThreadPoolExecutor来实现出来的。只是因为ThreadPoolExecutor这个线程池用起来有些麻烦，所以才提供了工厂类，让我们用起来比较简单。ThreadPoolExecutor用起来麻烦的原因主要是因为它提供的功能更强大。所以也需要我们对它的构造方法进行掌握。

ThreadPoolExecutor这个类也在 java.util.concurrent包底下，这个包里放的很多类都是和并发编程（多线程编程）密切相关的。