Java之线程池

今天药忘吃喽~ 2024-03-22 15:30 29阅读 0赞

**目录**

一.上节复习

1.阻塞队列

二.线程池

1.什么是线程池

2.为什么要使用线程池

3.JDK中的线程池

三.工厂模式

1.工厂模式的目的

四.使用线程池

1.submit()方法

2.模拟两个阶段任务的执行

五.自定义一个线程池

六.JDK提供线程池的详解

1.如何自定义一个线程池?

2.创建线程池的构造方法的参数及含义

3.描述线程池的工作原理

4.拒绝策略

5.为什么不推荐使用系统自带的线程池

七.自定义线程池

1.自定义线程池

2.拒绝策略测试

--------------------

## 一.上节复习 ##

上节内容指路:[Java之阻塞队列和消息队列][Java]

### 1.阻塞队列 ###

基于阻塞队列和生产者消费者模型可以实现消息队列

wait()和notify()使用的时机

虚假唤醒:把wait()的判断条件放在一个while循环里面,唤醒之后需要重新检查等待条件

## 二.线程池 ##

### 1.什么是线程池 ###

JDBC编程中,通过DataSource获取Connection就用到了池(数据库连接池)的概念 数据库连接池中有一些已经建立了连接(输入完账号密码的状态)的connection

![476d4e7875794907b483159ddd2cce8d.png][]

当Java程序需要数据库连接时,只需要从数据库连接池中获取到一个空闲的连接进行使用

当Java程序使用完连接之后,就会将当前连接返还给数据库连接池

**线程池里放的是线程本身,当程序启动时就创建若干个线程,如果有任务就处理,没有任务就阻塞等待.**

### 2.为什么要使用线程池 ###

为了减少系统创建线程的开销

如果我们不使用线程池,每一次使用创建线程,销毁线程(**用户态到内核态**),很浪费系统的资源,而且再多线程的环境下,我们一次使用可能是多个线程,多个一起创建很浪费系统的资源,大大减少了系统执行的效率.使用线程池,每一次到池中拿到一个线程,只需要涉及到用户态的操作.

### 3.JDK中的线程池 ###

> **1. 用来处理大量短时间工作任务的线程池,如果池中没有可用的线程将创建新的线程，如果线程空闲60秒将收回并移出缓存  
> ExecutorService cachedThreadPool = Executors.newCachedThreadPool();**

> **2. 创建一个操作无界队列且初始线程数为n的线程池  
> ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);**

无界队列: 指的是对队列中的元素个数不加限制,可能出现内存被消耗殆尽的情况

> **3. 创建一个操作无界队列且只有一个工作线程的线程池  
> ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();**

> **4. 创建一个单线程执行器，可以在给定时间后执行或定期执行。  
> ScheduledExecutorService singleThreadScheduledExecutor = Executors.newSingleThreadScheduledExecutor();**

> **5. 创建一个指定大小的线程池，可以在给定时间后执行或定期执行。  
> ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);**

> **6. 创建一个指定大小（不传入参数，为当前机器CPU核心数）的线程池，并行地处理任务不保证处理顺序**  
> **ExecutorService executorService = Executors.newWorkStealingPool();**

## 三.工厂模式 ##

### 1.工厂模式的目的 ###

**解决构造方法创建对象的缺陷**

**以下情况会发生问题,(id,name)和(age,name)会出现相同的参数列表不能够重载,因此不能同时书写这两个构造方法**

![5aa98dbc10e74b319daa01e4d6e33872.png][]

我们可以通过两个静态方法来进行创建

class Student {
        private int id;
        private int age;
        private String name;
    
        public static Student createByIdAndName(int id, String name) {
            Student student = new Student();
            student.setId(id);
            student.setName(name);
            return student;
        }
    
        public static Student createByAgeAndName(int age, String name) {
            Student student = new Student();
            student.setAge(age);
            student.setName(name);
            return student;
        }
    
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }

## 四.使用线程池 ##

### 1.submit()方法 ###

![ddb932fbf4314746a3af46ce5f2ad70c.png][]

通过submit方法可以看出我们可以提交任务到线程池,线程池中提供线程进行执行任务.

### 2.模拟两个阶段任务的执行 ###

public class Demo03_ThreadPoolUse {
        public static void main(String[] args) throws InterruptedException {
            //创建一个初始大小为3的线程池
            ExecutorService threadPool = Executors.newFixedThreadPool(3);
            for (int i = 0; i < 10; ++i) {
                int taskId = i;
                threadPool.submit(() -> {
                    System.out.println("我是任务:" + taskId+","+Thread.currentThread().getName());
    
                });
            }
    
            //模拟线程等待一段时间
            TimeUnit.SECONDS.sleep(5);
            System.out.println("第二阶段开始");
            for (int i = 10; i < 20; ++i) {
                int taskId = i;
                threadPool.submit(() -> {
                    System.out.println("我是任务:" + taskId+","+Thread.currentThread().getName());
    
                });
            }
    
    
        }
    }

**打印的内容:**

![0188c58a039b44c7aad4e644317529f3.png][]

**注意:此时程序并没有结束,在等待其他任务提交到线程池进行执行**

## **五.自定义一个线程池** ##

**1.可以提交任务到线程池,那么就需要一种数据结构来保存任务----可以考虑使用阻塞队列  
2.创建线程池需要指定初始的线程数量,这些线程不断的扫描阻塞队列,如果有任务就立即执行.**

可以考虑使用线程池对象的构造方法，接收要创建线程的数据并在构造方法中完成线程的创建

public class MyThreadPool {
        //定义一个阻塞队列来保存要执行的任务
        BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(3);
    
        //提供一个方法,用来提交任务
        public void submit(Runnable runnable) throws InterruptedException {
            queue.put(runnable);
        }
    
        //构造方法完成线程的初始化
        public MyThreadPool(int capacity) {
            if (capacity <= 0) {
                throw new IllegalArgumentException("capacity is illegal");
            }
            //完成线程的创建,扫描队列,取出任务并执行
            for (int i = 0; i < capacity; i++) {
                Thread thread = new Thread(() -> {
                    while (true) {
                        //取出任务
                        try {
                            Runnable take = queue.take();
                            take.run();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
    
                });
                thread.start();
            }
        }
    }

测试自定义的线程池:

public class Demo04_MyThreadPool {
        public static void main(String[] args) throws InterruptedException {
            //创建一个初始大小为3的线程池
            MyThreadPool threadPool = new MyThreadPool(3);
            for (int i = 0; i < 10; ++i) {
                int taskId = i;
                threadPool.submit(() -> {
                    System.out.println("我是任务:" + taskId + "," + Thread.currentThread().getName());
    
                });
            }
    
            //模拟线程等待一段时间
            TimeUnit.SECONDS.sleep(2);
            System.out.println("第二阶段开始");
            for (int i = 10; i < 20; ++i) {
                int taskId = i;
                threadPool.submit(() -> {
                    System.out.println("我是任务:" + taskId + "," + Thread.currentThread().getName());
    
                });
            }
        }
    }

打印结果:

![0eb281a572f949439100a589601364b4.png][]

## 六.JDK提供线程池的详解 ##

### 1.如何自定义一个线程池? ###

通过工厂方法获得的线程池最终都是创建一个ThreadPoolExecutor对象

![a3184e9e093b4c2cbfb1093beec2e9da.png][]

### 2.创建线程池的构造方法的参数及含义 ###

![452b2073c75b4cf9ba11ad6dfc488288.png][]

1.  **int corePoolSize 核心线程数,创建线程是包含的最小线程数**
2.  **int maximumPoolSize 最大线程数,也叫临时线程数(核心线程数不够时,允许创建最大的线程数)**
3.  **long keepAliveTime 临时空闲时长,超过这个时间自动释放**
4.  **TimeUnit unit 空闲的时间单位,和keepAliveTime一起使用**
5.  **BlockingQueue<Runnable> workQueue 用来保存任务的阻塞队列**
6.  **ThreadFactory threadFactory 线程工厂,如何去创建线程**
7.  **RejectedExecutionHandler handler 拒绝策略,触发的时机,当线程池处理不了过多的任务**

### 3.描述线程池的工作原理 ###

即上面七个参数如何搭配使用

先来举一个现实中的例子帮助我们理解工作原理:饭店老板根据人流量安排桌子数(**线程数**)

1.饭店里面初始有五张桌子(**核心线程数为5**)

2.下午3点,人数少于5,5张桌子足够接待顾客(**核心线程数大于任务数**)

3.到了晚饭点,人数大于5,不够接待顾客,顾客需要拿号排队等待(**向阻塞队列加入任务**)

4.排号人数过多,老板在饭店门口临时加了10张桌子(**创建10个临时线程**)

5.在用餐高峰期,门口10张桌子全部用完,排号也特别多,就让新来的顾客下次再来(**执行拒绝策略**)

6.当人数减少,门口10张桌子空了下来,过了半小时还没人来,将10张桌子回收(**临时线程达到空闲时常,回收临时线程**)

![0c446c3bfdc64c5294de5980c22f32a8.png][]

1.  当任务添加到线程池中时,先判断任务数是否大于核心线程数,如果不大于,直接执行任务
2.  任务数大于核心线程数,则加入阻塞队列
3.  当阻塞队列满了之后,会创建临时线程,会按照最大线程数,一次性创建到最大线程数
4.  当阻塞队列满了并且临时线程也创建完成,再提交任务,就会执行拒绝策略.
5.  当任务减少,临时线程达到空闲时长时,会被回收.

### 4.拒绝策略 ###

![239a6b161ffa4808b7bc1fc41d716062.png][]

**AbortPolicy:直接拒绝任务的加入,并且抛出RejectedExecutionException异常**

**CallerRunsPolicy:返回给提交任务的线程执行**

**DiscardOldestPolicy:舍弃最老的任务**

**DiscardPolicy:舍弃最新的任务**

**根据自己的业务场景选择合适的拒绝策略**

### 5.为什么不推荐使用系统自带的线程池 ###

**1.由于使用了无界队列,可能会有内存耗尽的风险**

![73c358f217b74f1e992dd31a6ddbd09c.png][]![a9d989544616414e80dc4aeda68d0df2.png][]**默认是长度最大的阻塞队列**

**2.临时线程数无法控,也可能会存在资源耗尽**

![80c38abdff824dbda8905cbb272d6e15.png][]

## 七.自定义线程池 ##

### 1.自定义线程池 ###

public class Demo_05_Create {
        public static void main(String[] args) throws InterruptedException {
            //创建线程池并指定参数
            ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 5, 1, TimeUnit.SECONDS,
                    new LinkedBlockingQueue<>(10), new ThreadPoolExecutor.AbortPolicy());
    
            for (int i = 0; i < 10; ++i) {
                int taskId = i;
                threadPool.submit(() -> {
                    System.out.println("我是任务:" + taskId + "," + Thread.currentThread().getName());
    
                });
            }
    
            //模拟线程等待一段时间
            TimeUnit.SECONDS.sleep(5);
            System.out.println("第二阶段开始");
            for (int i = 10; i < 20; ++i) {
                int taskId = i;
                threadPool.submit(() -> {
                    System.out.println("我是任务:" + taskId + "," + Thread.currentThread().getName());
    
                });
            }
    
    
        }
    }

### 2.拒绝策略测试 ###

**1.AbortPolicy**

**将阻塞队列的大小改为1,然后在执行方法**

![34588453d4604f8fa7de846812fc21b5.png][]

**2.CallerRunsPolicy**

**返回给调用者main方法线程**

![d8f66f2a9d3e4cffa783dd4f682b6b43.png][]

**3.DiscardOldestPolicy**

**抛弃了一部分的任务,老的**

![b34357efa6a443d38cf0b5250f9ad685.png][]

**4.DiscardPolicy**

**抛弃了一部分的任务,新的**

![b9ba332e621a4b36b1828bd80e7b6740.png][]

[Java]: https://blog.csdn.net/qq_64580912/article/details/130618008
[476d4e7875794907b483159ddd2cce8d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/88e36a24fa234eeaa8d1c03f56041657.png
[5aa98dbc10e74b319daa01e4d6e33872.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/81a3600e2a8e458fbd009f7e776297d8.png
[ddb932fbf4314746a3af46ce5f2ad70c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/6660a75493fd4d64b3687462ee7fbb34.png
[0188c58a039b44c7aad4e644317529f3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/489aae2e5603476aa587ca0f01bae70d.png
[0eb281a572f949439100a589601364b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/cb07c2131b15430e88c824ce87c4335e.png
[a3184e9e093b4c2cbfb1093beec2e9da.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/b6bbfa8289074f9ba176854a51f68f82.png
[452b2073c75b4cf9ba11ad6dfc488288.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/42b5d8d335194b2dbf4e4c2284d40031.png
[0c446c3bfdc64c5294de5980c22f32a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/112688906bac4f17a470f3b34d896658.png
[239a6b161ffa4808b7bc1fc41d716062.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/62480d157e1545e8be36eba128851b83.png
[73c358f217b74f1e992dd31a6ddbd09c.png]: https://img-blog.csdnimg.cn/73c358f217b74f1e992dd31a6ddbd09c.png
[a9d989544616414e80dc4aeda68d0df2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/143a50eff44047b786aef1383ee6502c.png
[80c38abdff824dbda8905cbb272d6e15.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/1a1b3a44c47c43469c4369fe44afb169.png
[34588453d4604f8fa7de846812fc21b5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/8dbdb8f65e984f229d9ef7ac862f6b58.png
[d8f66f2a9d3e4cffa783dd4f682b6b43.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/7b5b935ee457493cafb9b7740a9edb32.png
[b34357efa6a443d38cf0b5250f9ad685.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/f78553a997f548b8bbb97cdd77c12779.png
[b9ba332e621a4b36b1828bd80e7b6740.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/c5a2a64ca5f140439e02e14be0ac5c0b.png