【多线程】线程池详解

什么是线程池

线程池其实就是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后在创建线程后自动启动这些任务。这里的线程就是我们前面学过的线程，这里的任务就是我们前面学过的实现了Runnable或Callable接口的实例对象；
线程池是一种池化的技术实现，池化技术的核心思想就是实现资源的复用，避免资源的重复创建和销毁带来的性能开销。线程池可以管理一堆线程，让线程执行完任务之后不进行销毁，而是继续去处理其它线程已经提交的任务。

生活案例理解线程池

参数说明：
● 核心线程数量：当有一个任务提交到线程池中的时候，如果当前运行的线程数量没有达到核心线程数 量，那么就会新开一个线程去执行。（允许创建出来的线程数量）
● 最大线程数量：控制程序中最大的线程数量
● 最大空闲时间：线程在不执行的时候，最大允许存活的时间，达到最大空闲时间之后，就会回收线程
● 任务队列：当达到核心线程之后，后来的线程就会加到任务队列中，任务队列加满之后，就会按照设定的最大线程数来创建线程

通过案例理解上面的各个参数：
客户（任务）去银行（线程池）办理业务，但银行刚开始营业，窗口服务员还未就位(相当于线程池中初始线程数量为0)，
于是经理（线程池管理者）就安排1号工作人员(创建1号线程执行任务)接待客户（创建线程）：
在客户业务还没办完时，b客户（任务）又来了，于是经理（线程池管理者）就安排2号工作人员(创建2号线程执行任务)接待扑客户（仅创健了一个新的线程）
假设该银行总共就2个窗口(核心线程数量是2)：
紧接着在，b客户都没有结束的情况下c客户来了，于是经理（线程池管理者）就安排c客户先坐到银行大厅的座位上（空位相当于是任务队列等候
并告知他：如果1、2号工作人员空出，c就可以前去办理业务：
此时d客户又到了银行，(工作人员都在忙，大厅座位也满了)于是经理赶紧安排临时工（新创建的线程）在大堂站着，手持却d设备给d客户办理业务，
假如前面的业务都没有结束的时候客户又来了，此时正式工作人员都上了，临时工也上了，座位也满了（临时工加正式员工的总数量就是最大线程数），
于是经理只能按《超出银行最大接待能力处理办法》（饱和处理机制）拒接接待客户：
最后，进来办业务的人少了，大厅的临时工空闲时间也超过了1个小时（最大空闲时间），经理就会让这部分空闲的员工人下班（销毁线程）
但是为了保证银行银行正常工作(有一个allowCoreThreadTimeout变量控制是否允许销毁核心线程，默认false),即使正式工闲着，也不得提前下班，所
以1、2号工作人员继续待着（池内保持核心线程数量）：

为什么使用线程池

使用线程池最大的原因就是可以根据系统的需求和硬件环境灵活的控制线程的数量，且可以对所有线程进行统一的管理和控制，从而提高系统的运行效率，降低系统运行运行压力；当然了，使用线程池的原因不仅仅只有这些，我们可以从线程池自身的优点上来进一步了解线程池的好处：

线程池的优点

1:线程和任务分离，提升线程重用性：
2:控制线程并发数量，降低服务器压力，统一管理所有线程；
3:提升系统响应速度，假如创建线程用的时间为T1,执行任务用的时间为T2,销毁线
程用的时间为T3,那么使用线程池就免去了T1和T3的时间；

4降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
5提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
6提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控

自定义线程池

MyWorker类：线程执行的逻辑，用于保存线程的名字

public class MyWorker extends Thread {
    private String name;//用于保存线程的名字
    private List<Runnable> tasks;

    public MyWorker(String name,  List<Runnable> tasks) {
        super(name);

        this.tasks = tasks;
    }

    @Override
    public void run() {
        //判断集合中是否有任务，只要有，就一直执行任务
        while (tasks.size()>0){
            Runnable r=tasks.remove(0);
            r.run();
        }
    }
}

MyThreadPool类：自定义线程池

public class MyThreadPool {
    //1、任务队列  集合额 蓄意奥控制线程安全问题
    private List<Runnable> tasks= Collections.synchronizedList(new LinkedList<>());
    //2、当前线程数量
    private int num;
    //3、核心线程数量
    private int corePoolSize;
    //4、最大线程数量
    private int maxSize;
    //5、任务队列的长度
    private int workSize;

    public MyThreadPool(int corePoolSize, int maxSize, int workSize) {
        this.corePoolSize = corePoolSize;
        this.maxSize = maxSize;
        this.workSize = workSize;
    }

    //提交任务
    public void submit(Runnable r){
        //判断当前集合中任务数量，是否超出了最大任务数量
        if (tasks.size()>=workSize){
            System.out.println("任务："+r+"被丢弃了……");
        }else{
            tasks.add(r);
            //执行任务
            execTask(r);
        }
    }
    //执行任务
    private void execTask(Runnable r) {
        //判断当前线程池中线程总数量，是否超出了核心数
        if (num<corePoolSize){
            new MyWorker("核心线程："+num,tasks).start();
            num++;
        }else if(num<maxSize){
            new MyWorker("非核心线程："+num,tasks).start();
            num++;
        }else {
            System.out.println("任务："+r+"被缓存了……");
        }
    }

}

MyTask：该类为任务类，包含任务编号，每一个任务执行时间设计为0.2s

public class MyTask implements Runnable{
    private int id;
    //由于run方法是重写接口中的方法，所以id这个属性初始化可以利用构造方法
    public MyTask(int id){
        this.id=id;
    }
    @Override
    public void run() {
        String name=Thread.currentThread().getName();
        System.out.println("线程："+name+"即将执行任务："+id);
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程："+name+"完成了任务："+id);
    }
}

测试类：

public class MyTest {
    public static void main(String[] args) {
        //创建线程池对象
        MyThreadPool pool=new MyThreadPool(2,4,20);
        //提交多个任务
        for (int i = 0; i < 10; i++) {
            //创建任务对象，并提交给线程池
            MyTask my=new MyTask(i);
            pool.submit(my);
        }
    }
}

可以修改测试类中的任务个数，可以看到一些线程被丢弃了

内置线程池

ExecutorService接口是java内置的线程池接口，通过学习接口中的方法，可以快速的掌握java内置线程池的基本使用
常用方法：
void shutdown()启动一次顺序关闭，执行以前提交的任务，但不接受新任务。
ListshutdownNow()停止所有正在执行的任务，暂停处理正在等待的任务，并返回等待执行的任务列表。
Futuresubmit(Callabletask)执行带返回值的任务，返回一个Future对象。
Future<?>submit(Runnable task)执行Runnable任务，并返回一个表示该任务的Future.
Futuresubmit(Runnable task,T result)执行Runnable任务，并返?一个表示该任务的Future。

public class MyTest {
    public static void main(String[] args) {
//        extracted();
        test2();
    }
//练习newCachedThreadPool方法
    private static void extracted() {
        //使用工厂类获取线程池对象
        ExecutorService es=Executors.newCachedThreadPool();
        //提交任务
        for (int i = 0; i < 10; i++) {
            es.submit(new MyRunnable(i));
        }
    }

    private static void test2() {
        //使用工厂类获取线程池对象
        ExecutorService es=Executors.newCachedThreadPool(new ThreadFactory() {
            int n=1;
            @Override
            public Thread newThread(Runnable r) {
               return new Thread(r,"自定义的下称名称"+n++);
            }
        });
        //提交任务
        for (int i = 0; i < 10; i++) {
            es.submit(new MyRunnable(i));
        }
    }
}
//任务类，包含一个任务编号，在任务中打印出是哪一个线程正在执行任务
  class MyRunnable implements Runnable{
    private int id;

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

     @Override
     public void run() {
        //获取线程的名称，打印一句话
         String name=Thread.currentThread().getName();
         System.out.println(name+"执行了任务……"+id);
     }
 }

总结

线程池是一种常用的多线程编程技术，通过预先创建一定数量的线程并管理它们的生命周期，可以避免频繁创建和销毁线程带来的开销，同时也能够控制线程的数量和执行顺序，提高系统的性能和稳定性。

在使用线程池时，需要根据实际需求选择不同的线程池类型和参数配置。常用的线程池类型包括FixedThreadPool、CachedThreadPool、SingleThreadExecutor等，每种类型都有其特点和适用场景。此外，还需要关注线程池的参数配置，如核心线程数、最大线程数、任务队列、线程存活时间等等。

除了基本的线程池功能，还可以通过拓展线程池来满足特定的需求，如定时任务、异步任务、优先级任务等。在拓展线程池时，可以使用ThreadPoolExecutor或者自定义ThreadPoolExecutor的子类，并重写其中的方法来实现额外的功能。

总之，线程池是一种重要的多线程编程技术，可以有效地提高系统的性能和稳定性。在使用线程池时，需要根据实际需求选择不同的线程池类型和参数配置，并注意线程安全问题和线程池的调优和监控。