【JavaEE】——线程池大总结

（1）核心线程数

int corePoolSize

core（核心）pool（池）siz（大小）

（2）最大线程数

int maximumPoolSize

核心线程可以理解为公司的正式员工，不能轻易裁掉；

普通线程可以理解为公司的实习生，裁掉比较容易

最大线程数 = 核心线程数 +普通线程数

（3）保持存活时间

long keepAliveTime

（4）时间单位

TimeUnit unit

单位：s，min，hour.......

普通线程能空闲的最大时间，超过空闲时间限制，就会被移除线程池

还是用上述例子举例，实习生不能说开就开，假定摸鱼时间限制为1个小时，只要实习生摸鱼的时间小于1个小时就不会被开，超过就被开

（5）工作任务

BlockingQueue<Runnable> workQueue

与定时器（上篇文章）相似，线程池可以持有多个任务

Runnable用来描述任务的主体

<>也可以写PriorityQueue优先级队列

（6）线程工厂

ThreadFactory threadFactory

①工厂模式

通过（"工厂类"）类里面的（不一定是静态的）方法，对方法内部的new对象进行构造，完成对象的初始化（相当于，给构造方法外面在套上一层方法------套娃"封装"）

（7）拒绝策略（面试高频）

RejectedExecutionHandler handler------

execution（执行）handler（操作者）

问题：试想，线程池中有一个阻塞队列，存放的线程数目已经达到最大荣达，这个时候还往里面存放，那么线程池会怎么办？

①中止策略

.AbortPolicy ------

如果硬要在加新任务的话，线程池：我吃柠檬，lz新旧任务都不干了，抛出异常

②甩锅策略

.CallerRunsPolicy------

线程池：让交代给我这个任务的人自己完成这个线程，我才不干

③喜新厌旧

.DiscardOldestPolicy------

discard（丢弃）

线程池抛弃池中呆的最久最老的一个线程，迎接新欢（喜新厌旧）

④忠贞不渝

.DiscardPolicy------

丢弃要新添加的任务，继续我行我素执行线程池中本来就有的任务

三：Executors（工厂类）

因为ThreadPoolExecutor使用起来较为复杂，所以标准库中就封装了一下，提供了Executors这个版本（工厂类，在内部把ThreadPoolExecutor创建好了，并且设置了不同的参数）

1：.newFixedThreadPool（可以设定固定线程数目）

2：submit添加任务

package thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadDemon34 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(4);
        service.submit(new Runnable(){
            @Override
            public void run() {
                System.out.println("执行线程池中第一个任务");
            }
        });

    }
}

返回值类型点进去

3：线程池中线程数量问题

（1）前引

我们知道，线程的运行效率，跟cpu的逻辑核心数直接相关，假设cpu的逻辑核心数为N，那线程的数量该是多少合适（2N？1.5N？N？..........）

（2）线程任务的分类

①CPU密集型任务

线程大部分时间都在CPU上运行，计算

②IO密集型任务

大部分时间都在等待IO（input，output）。例如：Scanner读取用户的输入

（3）分情况讨论

到底在线程池中添加多少线程数量合适呢？

如果线程多为CPU类型的，那线程数目尽量不要超过N

如果线程多为IO类型的，那线程数目就可以远远超过N

但是具体开发肯定是需要我们多次测试，通过观察系统资源消耗，来找出最合适的添加数目的。

四：通过代码实现简单的线程池

1：思路

大逻辑其实就是，把创建的任务提交上去，再把任务取出来，在run执行就可以了就是这么简单

我们用到的IDEA自带的顺序表，阻塞队列BlockingQueue都其实是一个工具罢了~~

2：代码示例

java 复制代码

package thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-09-27
 * Time: 16:48
 */


class MyThreadPoolExecutor{
    //2:创建一个顺序表来接收创建的线程
    private List<Thread> threadList = new ArrayList<>();
    //4创建一个容量合适的阻塞队列
    private BlockingQueue<Runnable> queue = new ArrayBlockingQueue(1000);
    //1:通过一个循环，n的值，来控制产生的线程的数量
    public MyThreadPoolExecutor(int n){
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(()->{
                //6:把要做的任务从任务队列中不停地取出来，并且执行
                while(true){
                    try {
                        
                        //带有阻塞的take取出元素
                        Runnable runnable = queue.take();
                        runnable.run();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }

            });
            t.start();
            //3:
            threadList.add(t);
        }
    }
    //5:提交runnable到队列里面去
    public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }
}
public class ThreadDemon35 {
    //大逻辑其实就是，把创建的任务提交上去，再把任务取出来，在run执行就可以了就是这么简单
    public static void main(String[] args) throws InterruptedException {
        MyThreadPoolExecutor executor = new MyThreadPoolExecutor(4);
        for (int i = 0 ; i < 1000 ; i++){
            //变量捕获
            int n = i;
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行任务：" + n + "  " + "当前线程为：" + Thread.currentThread().getName());
                }
            });
        }
    }
}