Java多线程 - 创建线程池的方法 - ThreadPoolExecutor和Executors

线程池(重点)

线程池介绍

什么是线程池?

线程池就是一个可以复用线程的技术。

不使用线程池的问题:

如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

线程池工作原理:

例如线程池中最多可以允许创建三个工作线程, 也叫核心线程, 前面三个任务来的时候会给前面三个任务单独创建三个线程; 但是后面任务再来的时候, 因为创建的工作线程已达到最大数, 那么后面的任务就会进入任务队列中排队等待; 等前面的任务执行完成, 有空闲的线程的时候使用空闲的线程依次执行任务队列中的任务

实现线程池的方式

谁代表线程池?

JDK 5.0起提供了代表线程池的接口：ExecutorService

如何得到线程池对象?

• 方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
• 方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象

方式一: 实现类ThreadPoolExecutor

ThreadPoolExecutor构造器的参数

ThreadPoolExecutor的构造器有如下参数

public ThreadPoolExecutor(int corePoolSize,                          int maximumPoolSize,                          long keepAliveTime,                          TimeUnit unit,                          BlockingQueue<Runnable> workQueue,                          ThreadFactory threadFactory,                          RejectedExecutionHandler handler) 

参数介绍:

• 参数一：指定线程池的线程数量(核心线程): corePoolSize ----> 不能小于0
• 参数二：指定线程池可支持的最大线程数： maximumPoolSize ----> 最大数量 >= 核心线程数量
• 参数三：指定临时线程的最大存活时间： keepAliveTime ----> 不能小于0
• 参数四：指定存活时间的单位(秒、分、时、天): unit ----> 时间单位
• 参数五：指定任务队列： workQueue ----> 不能为null
• 参数六：指定用哪个线程工厂创建线程： threadFactory ----> 不能为null
• 参数七：指定线程忙，任务满的时候，新任务拒绝策略： handler ----> 不能为null

新任务拒绝策略:

ThreadPoolExecutor创建线程池对象示例:

ExecutorService pools = new ThreadPoolExecutor(3,                    5,                    8,                    TimeUnit.SECONDS,                    new ArrayBlockingQueue<>(6),                    Executors.defaultThreadFactory(),                    new ThreadPoolExecutor.AbortPolicy());

思考:

临时线程什么时候创建啊?

• 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

什么时候会开始拒绝任务?

• 核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。

---

线程池处理Runnable任务

ExecutorService的常用方法:

演示代码:

创建一个Runnable任务线程类

public class MyRunnable implements Runnable{    @Override    public void run() {        for (int i = 0; i < 5; i++) {            System.out.println(Thread.currentThread().getName() + "线程执行输出: " + i);        }        // 为了测试, 我们让每个线程睡眠3秒        try {            System.out.println(Thread.currentThread().getName() + "线程进入休眠");            Thread.sleep(3000);            System.out.println(Thread.currentThread().getName() + "线程执行完成");        } catch (Exception e) {            e.printStackTrace();        }    }}

在主类中, 创建一个线程池对象并创建Runnable任务交给线程池处理

• 如果只有三个任务, 那么会被三个核心线程同时执行

public static void main(String[] args) {    // 1. 创建一个线程池对象 核心线程为5, 最大线程数5, 临时线程存活6秒, 任务队列最大为5    ExecutorService es = new ThreadPoolExecutor(3, 5, 6,            TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),            new ThreadPoolExecutor.AbortPolicy());    // 2. Runnable任务交给任务线程池处理    Runnable target = new MyRunnable();    // 三个Runnable任务会被核心线程执行    es.execute(target);    es.execute(target);    es.execute(target);}

• 打印结果如下

pool-1-thread-1线程执行输出: 0pool-1-thread-2线程执行输出: 0pool-1-thread-3线程执行输出: 0pool-1-thread-2线程执行输出: 1pool-1-thread-2线程执行输出: 2pool-1-thread-2线程执行输出: 3pool-1-thread-1线程执行输出: 1pool-1-thread-2线程执行输出: 4pool-1-thread-3线程执行输出: 1pool-1-thread-3线程执行输出: 2pool-1-thread-3线程执行输出: 3pool-1-thread-1线程执行输出: 2pool-1-thread-3线程执行输出: 4pool-1-thread-1线程执行输出: 3pool-1-thread-1线程执行输出: 4pool-1-thread-2线程进入休眠pool-1-thread-3线程进入休眠pool-1-thread-1线程进入休眠pool-1-thread-3线程执行完成pool-1-thread-1线程执行完成pool-1-thread-2线程执行完成

• 如果核心线程全部被占用, 那么后面的任务会进入任务队列中排队等待有空闲的核心线程; 由于我们设置的任务队列数是5, 所以进入任务队列的任务数量小于等于5时, 不会创建临时线程

public static void main(String[] args) {    // 1. 创建一个线程池对象 核心线程为5, 最大线程数5, 临时线程存活6秒, 任务队列最大为5    ExecutorService es = new ThreadPoolExecutor(3, 5, 6,            TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),            new ThreadPoolExecutor.AbortPolicy());    // 2. Runnable任务交给任务线程池处理    Runnable target = new MyRunnable();    // 三个Runnable任务会被核心线程执行    es.execute(target);    es.execute(target);    es.execute(target);    // 三个核心线程被占满, 会进入任务队列排队等待有空闲的核心线程    es.execute(target);    es.execute(target);    es.execute(target);    es.execute(target);    es.execute(target);}

• 由于核心线程都在忙, 任务队列也满了, 这时候我们再继续添加任务时, 就会创建临时线程; 因为我们设置的核心线程数是3个, 最大线程数是5个, 所以临时线程最多只会创建两个

public static void main(String[] args) {    // 1. 创建一个线程池对象 核心线程为5, 最大线程数5, 临时线程存活6秒, 任务队列最大为5    ExecutorService es = new ThreadPoolExecutor(3, 5, 6,            TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),            new ThreadPoolExecutor.AbortPolicy());    // 2. Runnable任务交给任务线程池处理    Runnable target = new MyRunnable();    // 三个Runnable任务会被核心线程执行    es.execute(target);    es.execute(target);    es.execute(target);    // 三个核心线程被占满, 会进入任务队列排队等待有空闲的核心线程(我们设置的任务队列最大允许排队5个任务)    es.execute(target);    es.execute(target);    es.execute(target);    es.execute(target);    es.execute(target);    // 三个核心线程都在忙, 任务队列满, 创建临时线程    es.execute(target);    es.execute(target);}

• 核心线程都忙, 任务队列满, 临时线程忙, 此时再继续添加任务就会触发拒绝任务策略

public static void main(String[] args) {    // 1. 创建一个线程池对象 核心线程为5, 最大线程数5, 临时线程存活6秒, 任务队列最大为5    ExecutorService es = new ThreadPoolExecutor(3, 5, 6,            TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),            new ThreadPoolExecutor.AbortPolicy());    // 2. Runnable任务交给任务线程池处理    Runnable target = new MyRunnable();    // 三个Runnable任务会被核心线程执行    es.execute(target);    es.execute(target);    es.execute(target);    // 三个核心线程被占满, 会进入任务队列排队等待有空闲的核心线程(我们设置的任务队列最大允许排队5个任务)    es.execute(target);    es.execute(target);    es.execute(target);    es.execute(target);    es.execute(target);    // 三个核心线程都在忙, 任务队列满, 创建临时线程    es.execute(target);    es.execute(target);    // 后续任务拒绝任务会被拒绝    es.execute(target);}

线程池处理Callable任务

ExecutorService常用方法:

注意: submit方法返回的是Future对象, Future对象是FutureTask对象继承的父类

演示代码:

定义一个Callable任务类, 用于计算1到n的和返回

package com.chenyq.d4_threadpool2;import java.util.concurrent.Callable;public class MyCallable implements Callable<String> {    private int n;    public MyCallable(int n) {        this.n = n;    }    @Override    public String call() throws Exception {        int sum = 0;        for (int i = 1; i <= n ; i++) {            sum += i;        }        // 为了测试, 让每一个线程任务睡眠3秒        System.out.println(Thread.currentThread().getName() + "线程进入睡眠");        Thread.sleep(3000);        System.out.println(Thread.currentThread().getName() + "线程执行完成");        return Thread.currentThread().getName() + "执行1-" + n + "结果是: " + sum;    }}

线程池处理Callable任务时的细节和处理Callable的一样, 这里不再一一赘述, 代码如下

public static void main(String[] args) {    // 1. 创建一个线程池对象 核心线程为5, 最大线程数5, 临时线程存活6秒, 任务队列最大为5    ExecutorService pool = new ThreadPoolExecutor(3, 5, 6,            TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),            new ThreadPoolExecutor.AbortPolicy());    // 2. 创建Callable任务, 调用submit方法, 交给任务线程池处理, 返回未来线程对象    // 三个Runnable任务会被核心线程执行    Future<String> f1 = pool.submit(new MyCallable(10));    Future<String> f2 = pool.submit(new MyCallable(20));    Future<String> f3 = pool.submit(new MyCallable(30));    // 三个核心线程被占满, 会进入任务队列排队等待有空闲的核心线程(我们设置的任务队列最大允许排队5个任务)    Future<String> f4 = pool.submit(new MyCallable(30));    Future<String> f5 = pool.submit(new MyCallable(40));    Future<String> f6 = pool.submit(new MyCallable(50));    Future<String> f7 = pool.submit(new MyCallable(40));    Future<String> f8 = pool.submit(new MyCallable(50));    // 三个核心线程都在忙, 任务队列满, 创建临时线程    Future<String> f9 = pool.submit(new MyCallable(80));    Future<String> f10 = pool.submit(new MyCallable(60));    // 后续任务拒绝任务会被拒绝    Future<String> f11 = pool.submit(new MyCallable(30));    // 3. 互获取未来线程的返回结果    try { // 正常的结果        System.out.println(f1.get());        System.out.println(f2.get());        System.out.println(f3.get());        System.out.println(f4.get());        System.out.println(f5.get());        System.out.println(f6.get());        System.out.println(f7.get());        System.out.println(f8.get());        System.out.println(f9.get());        System.out.println(f10.get());        System.out.println(f11.get());    } catch (Exception e) { // 异常的结果        e.printStackTrace();    }}

方式二: Executors工具类创建线程池

Executors得到线程池对象的常用方法如下(工具类的方法基本都是静态方法):

Executors：线程池的工具类通过调用方法返回不同类型的线程池对象。

注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的。

例如下面代码当我们通过newFixedThreadPool方法创建线程池对象时

ExecutorService pool = Executors.newFixedThreadPool(3);

它的源码是创建了一个核心线程3, 最大线程3, 意味着没有临时线程, 所以临时线程存活时间也为0, 源码如下

public static ExecutorService newFixedThreadPool(int nThreads) {    return new ThreadPoolExecutor(nThreads, nThreads,      0L, TimeUnit.MILLISECONDS,      new LinkedBlockingQueue<Runnable>());}

演示代码:

我们演示使用newFixedThreadPool(int nThreads)方法创建线程池.

在主类中创建Runnable任务提交到线程池

public static void main(String[] args) {    // 1. 创建线程池对象    ExecutorService pool = Executors.newFixedThreadPool(3);    // 2. 提交Runnable任务到线程池    pool.execute(new MyRunnable());    pool.execute(new MyRunnable());    pool.execute(new MyRunnable());    // 提交第四个任务就已经没有多余线程了, 会被拒绝    pool.execute(new MyRunnable());}

Executors执行Callable任务

public static void main(String[] args) throws Exception {    // 1. 创建线程池对象    ExecutorService pool = Executors.newFixedThreadPool(3);    // 2. 提交Callable任务    Future f1 = pool.submit(new MyCallable(10));    Future f2 = pool.submit(new MyCallable(20));    Future f3 = pool.submit(new MyCallable(30));    // 获取任务返回结果    System.out.println(f1.get());    System.out.println(f2.get());    System.out.println(f3.get());}

Executors使用可能存在的陷阱

大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

阿里巴巴开发手册中明确说明, 不允许Executors创建线程池

来源地址：https://blog.csdn.net/m0_71485750/article/details/127698353