线程池的使用:ExecutorService、CompletionService和CompletableFuture的区别

已于 2024-09-17 17:33:56 修改
阅读量661 收藏 10
点赞数 14
分类专栏： 原创 总结 自学 文章标签： java 开发语言 后端
于 2024-09-17 17:03:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/minyunfei6/article/details/142315576
版权
原创 同时被 3 个专栏收录
48 篇文章 0 订阅
订阅专栏
总结
42 篇文章 0 订阅
订阅专栏
自学
30 篇文章 0 订阅
订阅专栏

1、前言

       当我们需要处理批量任务的时候,经常会使用线程池来提高处理速度,但线程池的使用方式有多种,今天主要来介绍一下ExecutorService、CompletionService和CompletableFuture的区别。

2、结论

       这里先说结论,后面有代码论证
● ExecutorService：适用于需要管理和调度一组线程任务的场景，可以通过 Future 获取任务结果,它是根据任务的提交顺序来获取结果的。
● CompletionService：适用于需要按任务完成顺序处理结果的场景，基于 ExecutorService 实现。
● CompletableFuture：适用于复杂的异步编排和组合任务，提供更丰富的功能和流式 API，适合现代异步编程需求。 CompletableFuture.supplyAsync，然后再同步调用thenApply。

3代码论证

3.1、ExecutorService

       ExecutorService是根据任务提交的顺序来获取任务处理结果的,也就是先提交的任务先会被获取结果,哪怕后提交的任务先被处理完成了。

package com.myf.Test.Test.current;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class ThreadPoolTest {

    public static AtomicInteger ThreadIndex = new AtomicInteger(0);
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10,
            1000L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(), task -> {
        Thread thread = new Thread(task);
        thread.setName("threadPoolExecutor-" + ThreadIndex);
        ThreadIndex.incrementAndGet();
        return thread;
    });


    public static void main(String[] args) {
        List<Future<String>> futureList = new ArrayList<>();
        for (int i = 10; i > 0; i--) {
            String a = i + "";
            futureList.add(threadPoolExecutor.submit(() -> add(a)));
        }
        System.out.println("开始获取结果:" + LocalDateTime.now());
        for (Future<String> future : futureList) {
            try {
                System.out.println(future.get() + ";" + LocalDateTime.now());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


    public static String add(String str) {
        try {
            Thread.sleep(Integer.parseInt(str) * 500L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return str + str + ";" + Thread.currentThread().getName();
    }

}

       如上我们创建了threadPoolExecutor线程池,核心线程池和最大线程数都是10,也就是全部都是核心线程,在main方法里创建了10个任务来使用线程池，add方法里做了线程休眠操作，第一个任务会休眠5s,第二个任务会休眠4.5s,以此类推,可知,后提交的任务休眠时间越来越短,最先被处理完，同时将处理任务的线程name打印了出来，我们来看下运行结果。

开始获取结果:2024-09-17T16:14:24.969
1010;threadPoolExecutor-0;2024-09-17T16:14:29.938
99;threadPoolExecutor-1;2024-09-17T16:14:29.938
88;threadPoolExecutor-2;2024-09-17T16:14:29.938
77;threadPoolExecutor-3;2024-09-17T16:14:29.938
66;threadPoolExecutor-4;2024-09-17T16:14:29.939
55;threadPoolExecutor-5;2024-09-17T16:14:29.939
44;threadPoolExecutor-6;2024-09-17T16:14:29.939
33;threadPoolExecutor-7;2024-09-17T16:14:29.939
22;threadPoolExecutor-8;2024-09-17T16:14:29.939
11;threadPoolExecutor-9;2024-09-17T16:14:29.939

       可以看到任务全部提交完到获取到第一个任务的处理结果耗时5s左右,就是因为提交的第一个任务休眠了5s导致的。

3.2、CompletionService

       CompletionService是根据任务完成的顺序来获取执行结果。

package com.myf.Test.Test.current;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class CompletionServiceTest {

    public static AtomicInteger ThreadIndex = new AtomicInteger(0);
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10,
            1000L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(), task -> {
        Thread thread = new Thread(task);
        thread.setName("threadPoolExecutor-" + ThreadIndex);
        ThreadIndex.incrementAndGet();
        return thread;
    });


    public static void main(String[] args) {
        CompletionService executorCompletionService= new ExecutorCompletionService<>(threadPoolExecutor);
        List<Future<String>> futureList = new ArrayList<>();
        for (int i = 10; i > 0; i--) {
            String a = i + "";
            futureList.add(executorCompletionService.submit(() -> add(a)));
        }
        System.out.println("开始获取结果:" + LocalDateTime.now());
        for (Future<String> future : futureList) {
            try {
                System.out.println(executorCompletionService.take().get() + ";" + LocalDateTime.now());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


    public static String add(String str) {
        try {
            Thread.sleep(Integer.parseInt(str) * 500L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return str + str + ";" + Thread.currentThread().getName();
    }
}

       通过executorCompletionService.take().get()可以阻塞式的获取优先执行完的结果

开始获取结果:2024-09-17T16:21:45.204
11;threadPoolExecutor-9;2024-09-17T16:21:45.657
22;threadPoolExecutor-8;2024-09-17T16:21:46.157
33;threadPoolExecutor-7;2024-09-17T16:21:46.656
44;threadPoolExecutor-6;2024-09-17T16:21:47.158
55;threadPoolExecutor-5;2024-09-17T16:21:47.657
66;threadPoolExecutor-4;2024-09-17T16:21:48.157
77;threadPoolExecutor-3;2024-09-17T16:21:48.658
88;threadPoolExecutor-2;2024-09-17T16:21:49.157
99;threadPoolExecutor-1;2024-09-17T16:21:49.657
1010;threadPoolExecutor-0;2024-09-17T16:21:50.157

       和前面一个相比,提交任务的顺序没有发生变化,但是获取任务执行结果的顺序变了,是因为后提交的任务休眠时间最短,所以会最先被执行完，而且可以看到每个任务执行完的时间都相差500ms左右。符合预期。

3.3、CompletableFuture

       如果我们有这样的一个场景,需要对批量任务执行完的结果做一些逻辑处理,那么我们就可以使用CompletableFuture了。

package com.myf.Test.Test.current;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class CompletableFutureTest {


    public static AtomicInteger ThreadIndex = new AtomicInteger(0);
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10,
            1000L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(), task -> {
        Thread thread = new Thread(task);
        thread.setName("threadPoolExecutor-" + ThreadIndex);
        ThreadIndex.incrementAndGet();
        return thread;
    });


    public static void main(String[] args) {

        List<CompletableFuture<String>> futureList = new ArrayList<>();
        for (int i = 10; i > 0; i--) {
            String a = i + "";
            futureList.add(CompletableFuture.supplyAsync(() -> add(a), threadPoolExecutor)
                    .thenApplyAsync(CompletableFutureTest::add2, threadPoolExecutor));
        }
        System.out.println("开始获取结果:" + LocalDateTime.now());
        for (CompletableFuture<String> future : futureList) {
            try {
                System.out.println(future.get() + ";" + LocalDateTime.now());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


    public static String add(String str) {
        try {
            Thread.sleep(Integer.parseInt(str) * 500L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return str + str + ";" + Thread.currentThread().getName();
    }

    public static String add2(String str) {

        return str + ";"  + Thread.currentThread().getName();
    }
}

       在这里我们增加了一个add2方法,在任务执行完add方法后,会拿add的出参作为add2方法的入参来运行。
开始获取结果:2024-09-17T16:38:31.378
1010;threadPoolExecutor-0;threadPoolExecutor-0;2024-09-17T16:38:36.331
99;threadPoolExecutor-1;threadPoolExecutor-1;2024-09-17T16:38:36.331
88;threadPoolExecutor-2;threadPoolExecutor-2;2024-09-17T16:38:36.331
77;threadPoolExecutor-3;threadPoolExecutor-3;2024-09-17T16:38:36.332
66;threadPoolExecutor-4;threadPoolExecutor-4;2024-09-17T16:38:36.332
55;threadPoolExecutor-5;threadPoolExecutor-5;2024-09-17T16:38:36.332
44;threadPoolExecutor-6;threadPoolExecutor-6;2024-09-17T16:38:36.332
33;threadPoolExecutor-7;threadPoolExecutor-7;2024-09-17T16:38:36.332
22;threadPoolExecutor-8;threadPoolExecutor-8;2024-09-17T16:38:36.332
11;threadPoolExecutor-9;threadPoolExecutor-9;2024-09-17T16:38:36.332
       我们可以看到,在add方法执行完之后紧接着用add的出参作为入参来来执行add2方法了。但这里获取任务执行结果是根据任务提交的顺序来排序的，这一点可能会影响效率。
       当然我们也可以改成按照任务完成的顺序来获取结果

package com.myf.Test.Test.current;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class CompletableFutureTest {


    public static AtomicInteger ThreadIndex = new AtomicInteger(0);
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10,
            1000L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(), task -> {
        Thread thread = new Thread(task);
        thread.setName("threadPoolExecutor-" + ThreadIndex);
        ThreadIndex.incrementAndGet();
        return thread;
    });


    public static void main(String[] args) {

        List<CompletableFuture<String>> futureList = new ArrayList<>();
        for (int i = 10; i > 0; i--) {
            String a = i + "";
            futureList.add(CompletableFuture.supplyAsync(() -> add(a), threadPoolExecutor)
                    .thenApplyAsync(CompletableFutureTest::add2, threadPoolExecutor));
        }
        System.out.println("开始获取结果:" + LocalDateTime.now());

        List<CompletableFuture<Void>> orderedFutures = new ArrayList<>();
        for (CompletableFuture<String> future : futureList) {
            CompletableFuture<Void> orderedFuture = future.thenAccept(result -> {
                System.out.println(result + ";" + LocalDateTime.now());
            });
            orderedFutures.add(orderedFuture);
        }

        // 等待所有任务完成
        CompletableFuture.allOf(orderedFutures.toArray(new CompletableFuture[0]));

    }


    public static String add(String str) {
        try {
            Thread.sleep(Integer.parseInt(str) * 500L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return str + str + ";" + Thread.currentThread().getName();
    }

    public static String add2(String str) {

        return str + ";" + Thread.currentThread().getName();
    }
}

借助allof来执行,而不是直接通过feature.get来获取执行结果。

开始获取结果:2024-09-17T17:32:18.482
11;threadPoolExecutor-9;threadPoolExecutor-9;2024-09-17T17:32:18.941
22;threadPoolExecutor-8;threadPoolExecutor-8;2024-09-17T17:32:19.442
33;threadPoolExecutor-7;threadPoolExecutor-7;2024-09-17T17:32:19.941
44;threadPoolExecutor-6;threadPoolExecutor-6;2024-09-17T17:32:20.445
55;threadPoolExecutor-5;threadPoolExecutor-5;2024-09-17T17:32:20.944
66;threadPoolExecutor-4;threadPoolExecutor-4;2024-09-17T17:32:21.444
77;threadPoolExecutor-3;threadPoolExecutor-3;2024-09-17T17:32:21.943
88;threadPoolExecutor-2;threadPoolExecutor-2;2024-09-17T17:32:22.445
99;threadPoolExecutor-1;threadPoolExecutor-1;2024-09-17T17:32:22.944
1010;threadPoolExecutor-0;threadPoolExecutor-0;2024-09-17T17:32:23.446
minyunfei6
关注
专栏目录
【Java多线程】JUC之线程池(五) CompletionService 、CompletableFuture
墩墩分墩
03-10 1437
- 异步编程是编写`非阻塞的代码`，运行的任务`在一个单独的线程`，与`主线程隔离`，并且会`通知主线程它的进度`，`成功或者失败`。在这种方式中，`主线程不会被阻塞`，不需要一直等到子线程完成。`主线程可以并行的执行其他任务。`使用这种并行方式，可以极大的提高程序的性能。
线程池——futuretask、CompletionService、CompletableFuture
m0_46598535的博客
06-25 2469
java
并发编程：浅谈CompletionService 和 CompletableFuture （附高德笔试题）
weixin_44735065的博客
04-13 1486
并发编程：浅谈CompletionService 和 CompletableFuture 目录并发编程：浅谈CompletionService 和 CompletableFuture一、CompletionService1. 原理2.应用场景3.使用案例案例一：向不同电商平台询价，并保存案例二：并行地调用多个服务，只要有一个成功就返回结果二、CompletableFuture1.应用场景a.依赖关系b.聚合关系（and）c.聚合关系（or）d.并行执行2.详解a.创建异步操作b.结果处理c.结果转换d.结果
Future、CompletionService、CompletableFuture介绍与对比
weixin_44153131的博客
01-04 1303
Future是JDK1.5 提供的接口，是用来以阻塞的方式获取线程异步执行完的结果。FutureTask 类是 Java 中 Future 接口的一个实现，同时也实现了 Runnable 接口。它用于表示异步计算的结果，允许一个任务在一个线程中计算结果，在另一个线程中获取计算的结果。// 创建一个固定大小的线程池 ExecutorService executorService = Executors . newFixedThreadPool(2);
Java多线程面试题：Java并发编程深度解析：线程池、CompletableFuture和CompletionService，解释Java中的CompletableFuture，以及它的使用场景
码农超哥的博客
02-26 1164
关注点：考察对线程池的理解，以及它在并发编程中的应用。考察方向：理解线程池的概念，以及如何使用线程池来管理线程。具体原理线程池是一种用于管理线程的组件，它可以重用已存在的线程，从而减少线程创建和销毁的开销。Java提供了线程池的实现类ExecutorService，它支持提交Runnable任务和Future结果。实操问题请给出一个使用ExecutorService的示例，展示如何提交和取消任务。描述线程池中的核心线程数和最大线程数的作用，以及如何设置这些参数。
异步编程-ExecutorService、CompletionService、CompletableFuture
Tong_zhi的博客
08-18 1161
1. ExecutorService中submit()和execute()的区别 execute只能提交Runnable类型的任务，无返回值。submit既可以提交Runnable类型的任务，也可以提交Callable类型的任务，会有一个类型为Future的返回值，但当任务类型为Runnable时，返回值为null。 submit()可以进行Exception处理：execute在执行任务时，如果遇到异常会直接抛出，而submit不会直接抛出，而是把异常保存在成员变量中，在FutureTask.get阻塞
并发编程之深入理解十三：CompletionService & CompletableFuture
Men-DD
03-11 1112
CompletionService Callable + Future 可以实现多个task并行执行，但是如果遇到前面的task执行较慢时需要阻塞等待前面的task执行完后面task才能取得结果。 而CompletionService的主要功能就是一边生成任务,一边获取任务的返回值。让两件事分开执行,任务之间不会互相阻塞，可以实现先执行完的先取结果，不再依赖任务顺序了。 CompletionService原理 内部通过阻塞队列+FutureTask，实现了任务先完成可优先获取到，即结果按照完成先后顺序排序
Java-多线程-Future、FutureTask、CompletionService、CompletableFuture解决多线程并发中归集问题的效率对比
迷路剑客个人博客
08-28 1655
转载声明 本文大量内容系转载自以下文章，有删改，并参考其他文档资料加入了一些内容： 【小家Java】Future、FutureTask、CompletionService、CompletableFuture解决多线程并发中归集问题的效率对比 作者：YourBatman 出处：CSDN 转载仅为方便学习查看，一切权利属于原作者，本人只是做了整理和排版，如果带来不便请联系我删除。 摘要 开启线程执行任务，不管是使用Runnable（无返回值不支持上报异常）还是Callable（有返回值支持上报异常）接口，都
CompletionService 和 CompletableFuture
weixin_39795049的博客
11-15 878
CompletionService 和 CompletableFuture
CompletionService 与 CompletableFuture 使用场景
08-30
`CompletionService` 和 `CompletableFuture` 都是 Java 中处理并发编程中异步任务完成情况的重要工具，它们分别对应于 `ExecutorService` 提供的 `Future` 接口以及 Java 8 引入的更高级别 API。 `...
多线程并发执行任务，取结果归集。终极总结：Future、FutureTask、CompletionService、CompletableFuture...
博客园搬家测试账号
04-10 1757
目录1.Futrue原理:demo:建议：此种方法可实现基本目标，任务并行且按照提交顺序获取结果。使用很普遍，老少皆宜，就是CPU有消耗，可以使用！2.FutureTask原理:demo:建议：demo1在特定场合例如有十分耗时的业务但有依赖于其他业务不一定非要执行的，可以尝试使用。demo2多线程并发执行并结果归集，这里多套一层FutureTask比较鸡肋（直接返回Future简单明了）不建议使...
Java异步编程之CompletableFuture
m0_73311735的博客
02-25 138
对于简单的并行任务，你可以通过“线程池 +Future”的方案来解决；如果任务之间有聚合关系，无论是 AND 聚合还是 OR 聚合，都可以通过来解决；而批量的并行任务，则可以通过来解决。
Future&CompletableFuture
Learning_foolish的博客
04-05 440
Future&FutureTask介绍
Java-网络
2301_81543552的博客
09-14 693
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 602
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 277
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1134
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
最新发布
xiaocaij_icai的博客
09-15 185
");
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值