imtoken钱包官方版下载安卓版|comp

首页
comp

imtoken钱包官方版下载安卓版|comp

作者： imtoken钱包官方版下载安卓版

2024-03-07 17:56:04

COMP中文(简体)翻译：剑桥词典

词典

翻译

语法

同义词词典

+Plus

剑桥词典+Plus

Shop

剑桥词典+Plus

我的主页

+Plus 帮助

退出

剑桥词典+Plus

我的主页

+Plus 帮助

退出

中文 (简体)

查找

英语-中文（简体）

comp 在英语-中文（简体）词典中的翻译

compverb [ T ] mainly US informal uk

Your browser doesn't support HTML5 audio

/kɒmp/ us

Your browser doesn't support HTML5 audio

/kɑːmp/

Add to word list

to give someone something valuable without asking for payment

馈赠，赠送

Usually, the writer's entire trip is comped.

一般来说作者全部旅程的费用都是全包的。

They comped us two tickets.

他们赠送我们两张票。

comped meals/drinks

馈赠的饭／饮料

to allow someone to do something without having to pay

让…不花钱（做某件事）

You can comp two guests.

你可以免费带两个客人来。

(comp在剑桥英语-中文（简体）词典的翻译 © Cambridge University Press)

comp的例句

comp

Almost all comp cards are in color but may include black-and-white images.

来自 Wikipedia

该例句来自维基百科，在CC BY-SA许可下可重复使用。

The band started to record a series of songs, most for the album and some for some splits and comps that were offered.

来自 Wikipedia

该例句来自维基百科，在CC BY-SA许可下可重复使用。

An artists proof is also known as a comp or complimentary if given to printers.

来自 Wikipedia

该例句来自维基百科，在CC BY-SA许可下可重复使用。

Strictly speaking, these operators are defined on all elements, but we require that 0 (e), 1 (e) are typed state if and only if e has type comp.

来自 Cambridge English Corpus

Locals casinos will typically offer comps, such as free meals at the casino's restaurants, at a higher rate than tourist-oriented casinos.

来自 Wikipedia

该例句来自维基百科，在CC BY-SA许可下可重复使用。

Many casinos have attached hotels, but those that don't may have the ability to comp rooms to a hotel nearby.

来自 Wikipedia

该例句来自维基百科，在CC BY-SA许可下可重复使用。

With respect to their rhythm, some palos such as grananas, malagueas, and fandango libre, are rendered in free rhythm, whereas most others are metered, that is, in comps.

来自 Wikipedia

该例句来自维基百科，在CC BY-SA许可下可重复使用。

I agree with "comps", but don't ruin the others.

来自 Hansard archive

该例句来自Hansard存档。包含以下议会许可信息开放议会许可v3.0

示例中的观点不代表剑桥词典编辑、剑桥大学出版社和其许可证颁发者的观点。

comp的翻译

中文（繁体）

饋贈，贈送, 讓…不花錢（做某件事）…

查看更多内容

西班牙语

forma abreviada de "competition":, competición, concurso…

查看更多内容

葡萄牙语

oferecer como cortesia, compensação, remuneração…

查看更多内容

需要一个翻译器吗？

获得快速、免费的翻译！

翻译器工具

comp的发音是什么？

在英语词典中查看 comp 的释义

浏览

Comoran

comorbid

comorbidity

Comoros

comp

comp time

compact

compact disc

compaction

comp更多的中文(简体)翻译

全部

comp time

fully comp

comp time, at compensatory time

查看全部意思»

“每日一词”

veggie burger

Your browser doesn't support HTML5 audio

/ˈvedʒ.i ˌbɜː.ɡər/

Your browser doesn't support HTML5 audio

/ˈvedʒ.i ˌbɝː.ɡɚ/

a type of food similar to a hamburger but made without meat, by pressing together small pieces of vegetables, seeds, etc. into a flat, round shape

关于这个

博客

Forget doing it or forget to do it? Avoiding common mistakes with verb patterns (2)

March 06, 2024

新词

stochastic parrot

March 04, 2024

已添加至 list

回到页面顶端

内容

英语-中文（简体）例句翻译

©剑桥大学出版社与评估2024

学习

新词

帮助

纸质书出版

Word of the Year 2021

Word of the Year 2022

Word of the Year 2023

开发

词典API

双击查看

搜索Widgets

执照数据

关于

无障碍阅读

剑桥英语教学

剑桥大学出版社与评估

授权管理

Cookies与隐私保护

语料库

使用条款

京ICP备14002226号-2

©剑桥大学出版社与评估2024

剑桥词典+Plus

我的主页

+Plus 帮助

退出

词典

定义

清晰解释自然的书面和口头英语

英语

学习词典

基础英式英语

基础美式英语

翻译

点击箭头改变翻译方向。

双语词典

英语-中文（简体）

Chinese (Simplified)–English

英语-中文（繁体）

Chinese (Traditional)–English

英语-荷兰语

荷兰语-英语

英语-法语

法语-英语

英语-德语

德语-英语

英语-印尼语

印尼语-英语

英语-意大利语

意大利语-英语

英语-日语

日语-英语

英语-挪威语

挪威语-英语

英语-波兰语

波兰语-英语

英语-葡萄牙语

葡萄牙语-英语

英语-西班牙语

西班牙语-英语

English–Swedish

Swedish–English

半双语词典

英语-阿拉伯语

英语-孟加拉语

英语-加泰罗尼亚语

英语-捷克语

英语-丹麦语

English–Gujarati

英语-印地语

英语-韩语

英语-马来语

英语-马拉地语

英语-俄语

English–Tamil

English–Telugu

英语-泰语

英语-土耳其语

英语-乌克兰语

English–Urdu

英语-越南语

翻译

语法

同义词词典

Pronunciation

剑桥词典+Plus

Shop

剑桥词典+Plus

我的主页

+Plus 帮助

退出

中文 (简体)

Change

English (UK)

English (US)

Español

Русский

Português

Deutsch

Français

Italiano

中文 (简体)

正體中文 (繁體)

Polski

한국어

Türkçe

日本語

Tiếng Việt

हिंदी

தமிழ்

తెలుగు

关注我们

选择一本词典

JAVA 多线程、CompleableFuture异步编程_java compositefuture-CSDN博客

JAVA 多线程、CompleableFuture异步编程

最新推荐文章于 2024-03-06 15:11:41 发布

qq_43659061

最新推荐文章于 2024-03-06 15:11:41 发布

阅读量919

点赞数

文章标签：

多线程

java

本文链接：https://blog.csdn.net/qq_43659061/article/details/112524134

版权

初始化线程的四种办法

继承Thread类实现Rannable 接口实现callable 接口 + FutureTask （可以获取处理结果和处理异常）线程池

继承Thread实现

public class ThreadTest {

public static void main(String[] args) {

System.out.println("主线程启动");

Thread1 thread1 = new Thread1();

thread1.start();

System.out.println("主线程结束");

}

public static class Thread1 extends Thread{

@Override

public void run() {

System.out.println("===========================");

System.out.println("当前线程---->"+Thread.currentThread().getId());

int i = 10 / 2;

System.out.println("当前线程处理结果---->"+i);

System.out.println("===========================");

}

执行结果：

实现Runnable接口实现

public class ThreadTest {

public static void main(String[] args) {

System.out.println("主线程启动");

new Thread(new Thread1()).start();

System.out.println("主线程结束");

}

public static class Thread1 implements Runnable{

@Override

public void run() {

System.out.println("===========================");

System.out.println("当前线程---->"+Thread.currentThread().getId());

int i = 10 / 2;

System.out.println("当前Runnable线程处理结果---->"+i);

System.out.println("===========================");

}

执行结果：

实现Runnable实现

可以使用FatureTask接收异步线程的执行结果，只有所有线程执行完才能得到结果，是阻塞等待

public class ThreadTest {

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println("主线程启动");

FutureTask futureTask = new FutureTask<>(new Thread1());

new Thread(futureTask).start();

//阻塞等待，当所有线程执行完才能得到结果

//等待整个线程执行完，获取执行结果

Integer integer = futureTask.get();

System.out.println("futureTask执行结果："+integer);

System.out.println("主线程结束");

}

public static class Thread1 implements Callable {

@Override

public Integer call() throws Exception {

System.out.println("===========================");

System.out.println("当前线程---->"+Thread.currentThread().getId());

int i = 10 / 2;

System.out.println("当前Callable线程处理结果---->"+i);

System.out.println("===========================");

return i;

}

执行结果：

线程池

为什么使用线程池：降低资源消耗：通过重复利用已经创建好的线程，减少线程创建销毁的损耗。

提高响应速度：因为线程池线程没有超过最大线程数时，有的线程处于空闲等待任务状态，当任务进来无需创建新的线程就能执行

提高线程的可管理性：线程池会根据系统的特点会对线程池内线程进行优化处理，减少创建和销毁带来的系统开销，无限的创建和销毁线程不仅损耗系统性能，还降低系统的稳定性，使用线程池来进行统一的管理分配

在我们的业务代码中，都不用以上三种但是，因为可能会导致我们的资源耗尽，这将会是没有更多的资源来处理核心业务。应该将所有的多线程异步任务都交给线程池，这样只有一个执行完才能继续拿到线程资源执行下一个任务，这样能有效的控制我们的资源。

创建线程池的方式

使用JUC包下的Executors来创建一个线程池

//固定长度的线程池

ExecutorService service = Executors.newFixedThreadPool(10);

service.execute(new Thread(()-> System.out.println("异步线程执行")));

这种方式有常见的四种线程池

Executors.newCachedThreadPool()：创建一个可缓存线程池，如果线程池长度超过需要处理，可灵活的回收空闲线程，没有则创建新线程

public static ExecutorService newCachedThreadPool() {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

60L, TimeUnit.SECONDS,

new SynchronousQueue());

}

Executors.newFixedThreadPool():创建一个固定大小的线程池，可控制线程的最大并发量，超出的将会在队列中等待。核心线程数等于最大线程数

public static ExecutorService newFixedThreadPool(int nThreads) {

return new ThreadPoolExecutor(nThreads, nThreads,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue());

}

Executors.newScheduledThreadPool():创建一个定时线程池，支持定时或周期性的执行任务Executors.newSingleThreadExecutor()：创建一个单线程的线程池，后台从队列中获取任务,挨个执行

public static ExecutorService newSingleThreadExecutor() {

return new FinalizableDelegatedExecutorService

(new ThreadPoolExecutor(1, 1,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue()));

}

使用new ThreadPoolExecutor();来创建线程池， ThreadPoolExecutor七大参数：

int corePoolSize：核心线程数，线程池创建好就准备就绪的线程数，等待异步任务执行，这些线程将会一直存在，除非allowCoreThreadTimeOutint maximumPoolSize：最大线程数，用来控制资源并发long keepAliveTime：存活时间，当线程数大于核心时，这是多余空闲线程在终止前等待新任务的最长时间，超过存活时间将会释放空闲线程TimeUnit unit：时间单位，存活时间的时间单位BlockingQueue workQueue：阻塞队列，如果任务有很多，查出最大线程数，多余的任务将会放入队列，等待线程空闲从队列中取出并继续执行ThreadFactory threadFactory：线程的创建工厂RejectedExecutionHandler handler：拒绝处理控制器,如果队列的满了，按照我们指定的拒绝策略来拒绝执行任务

工作顺序：

线程池创建，准备好核心线程数的核心线程，准备接收任务如果核心线程已经满了，后续进来的任务将放到阻塞队列中等待，当核心线程执行完以后就会从队列中获取任务执行如果阻塞队列满了，将会启动新的线程执行任务，最大数不能超过最大线程数，来进行资源控制如果最大线程数也用完，将会执行我们的拒绝策略RejectedExecutionHandler来拒绝任务如果最大线程数都执行完，有很多空闲的线程，这些线程将会在执行的存活之间过后进行释放，释放最大线程数-核心线程数，核心线程会一直存在

创建线城池创建一个核心数为10、最大线程数为100、存活时间为10秒，JUC包下LinkedBlockingDeque长度为1000的阻塞队列，JUC下默认的线程工厂defaultThreadFactory，ThreadPoolExecutor.AbortPolicy()直接丢弃的拒绝策略的线程池

ThreadPoolExecutor executor = new ThreadPoolExecutor(

10,

100,

10,

TimeUnit.SECONDS,

new LinkedBlockingDeque<>(1000),

Executors.defaultThreadFactory(),

new ThreadPoolExecutor.AbortPolicy()

);

比如一个线程池，核心线程8、最大线程20、阻塞队列50，如果此时进来100个请求进来将会怎么分配。

首先核心线程直接执行8个，这时候不会直接开其他线程，将会放到队列50个，队列满了以后将会开启12个线程，其他的任务都会被丢弃。

如果不想直接被丢弃，可以采用DiscardPolicy这种拒绝策略，这将会直接执行线程的run()方法，是同步执行

区别

继承Thread、实现Rannable接口创建出来的线程都不能得到返回值，Callable可以获取返回值以上三种都不能有效的控制资源使用线程池的方式来执行多线程任务可以有效控制资源，让性能更加稳定

CompletableFature异步编排

所谓异步调用其实就是实现一个可无需等待被调用函数的返回值而让操作继续运行的方法。在 Java 语言中，简单的讲就是另启一个线程来完成调用中的部分计算，使调用继续运行或返回，而不需要等待计算结果。但调用者仍需要取线程的计算结果。

JDK5新增了Future接口，用于描述一个异步计算的结果。虽然 Future 以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的初衷相违背，轮询的方式又会耗费无谓的 CPU 资源，而且也不能及时地得到计算结果。这时候就可以用到JDK8新增的CompletableFature来进行一步任务的组合，级联调用假设有三个异步任务A、 B、 C，异步任务都是同时执行，但是C任务需要A任务的执行结果来进行，这种情况就可以用到异步编排

* @author Doug Lea

* @since 1.8

public class CompletableFuture implements Future, CompletionStage {

/**

* 可以看到CompletableFuture实现了Future，和我们的Callablel实现线程的FutureTask类似，

* 都实现了Fature接口，可以获取异步任务的结果

public class FutureTask implements RunnableFuture {

public interface RunnableFuture extends Runnable, Future {

CompletableFature提供了四个方法给我们执行异步操作

/**

* 没有返回值的

public static CompletableFuture runAsync(Runnable runnable) {

return asyncRunStage(asyncPool, runnable);

}

/**

* 指定线程池的

public static CompletableFuture runAsync(Runnable runnable,

Executor executor) {

return asyncRunStage(screenExecutor(executor), runnable);

}

/**

* 有返回值的

public static CompletableFuture supplyAsync(Supplier supplier) {

return asyncSupplyStage(asyncPool, supplier);

}

/**

* 指定线程池的

public static CompletableFuture supplyAsync(Supplier supplier,

Executor executor) {

return asyncSupplyStage(screenExecutor(executor), supplier);

}

runAsync测试

public class ThreadTest {

private static ThreadPoolExecutor executor = new ThreadPoolExecutor(

10,

100,

10,

TimeUnit.SECONDS,

new LinkedBlockingDeque<>(1000),

Executors.defaultThreadFactory(),

new ThreadPoolExecutor.CallerRunsPolicy()

);

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println("主线程启动");

CompletableFuture.runAsync(()->{

int i = 10 / 5;

System.out.println(i);

},executor);

System.out.println("主线程结束");

}

supplyAsync测试

public class ThreadTest {

private static ThreadPoolExecutor executor = new ThreadPoolExecutor(

10,

100,

10,

TimeUnit.SECONDS,

new LinkedBlockingDeque<>(1000),

Executors.defaultThreadFactory(),

new ThreadPoolExecutor.CallerRunsPolicy()

);

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println("主线程启动");

CompletableFuture future = CompletableFuture.supplyAsync(() -> {

int i = 10 / 5;

System.out.println(i);

return i;

}, executor);

Integer integer = future.get();

System.out.println("异步执行结果："+integer);

System.out.println("主线程结束");

}

线程执行完回调

public class ThreadTest {

private static ThreadPoolExecutor executor = new ThreadPoolExecutor(

10,

100,

10,

TimeUnit.SECONDS,

new LinkedBlockingDeque<>(1000),

Executors.defaultThreadFactory(),

new ThreadPoolExecutor.CallerRunsPolicy()

);

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println("主线程启动");

CompletableFuture future = CompletableFuture.supplyAsync(() -> {

int i = 10 / 0;

return i;

}, executor).whenComplete((result,exception)->{

System.out.println("线程执行结果："+result);

System.out.println("线程执行异常："+exception);

}).exceptionally(throwable -> {

return 0;

});

Integer integer = future.get();

System.out.println("异步执行结果："+integer);

System.out.println("主线程结束");

}

链式调用whenComplete只能感知是否发生异常，并不能处理异常

使用handle来处理结果

public class ThreadTest {

private static ThreadPoolExecutor executor = new ThreadPoolExecutor(

10,

100,

10,

TimeUnit.SECONDS,

new LinkedBlockingDeque<>(1000),

Executors.defaultThreadFactory(),

new ThreadPoolExecutor.CallerRunsPolicy()

);

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println("主线程启动");

CompletableFuture future = CompletableFuture.supplyAsync(() -> {

int i = 10 / 2;

return i;

}, executor).handle((result,exception)->{

if (result != null){

return result;

}

if (exception != null){

return 0;

}

return 0;

});

Integer integer = future.get();

System.out.println("异步执行结果："+integer);

System.out.println("主线程结束");

}

线程串行化

/**

* 当一个线程依赖上一个线程时，获取上一个线程返回结果，并返回当前线程的结果

* A B两个线程，B 依赖 A 的返回结果时，B 可以获取 A 的返回结果拿过来计算，并返回 B 线程的执行结果

public CompletableFuture thenApply(

Function fn) {

return uniApplyStage(null, fn);

}

public CompletableFuture thenApplyAsync(

Function fn) {

return uniApplyStage(asyncPool, fn);

}

public CompletableFuture thenApplyAsync(

Function fn, Executor executor) {

return uniApplyStage(screenExecutor(executor), fn);

}

//===============================================================================

/**

* 当一个线程依赖上一个线程时，获取上一个线程返回结果，并拿来计算，当前线程并无返回结果

* A B 两个线程，B 可以拿到 A 线程的返回结果，并用 A 的返回结果来计算操作，B 没有返回结果

public CompletableFuture thenAccept(Consumer action) {

return uniAcceptStage(null, action);

}

public CompletableFuture thenAcceptAsync(Consumer action) {

return uniAcceptStage(asyncPool, action);

}

public CompletableFuture thenAcceptAsync(Consumer action,

Executor executor) {

return uniAcceptStage(screenExecutor(executor), action);

}

//===============================================================================

/**

* 只要上面的任务执行完成，就执行ThenRun（）方法，只是一个后续操作

public CompletableFuture thenRun(Runnable action) {

return uniRunStage(null, action);

}

public CompletableFuture thenRunAsync(Runnable action) {

return uniRunStage(asyncPool, action);

}

public CompletableFuture thenRunAsync(Runnable action,

Executor executor) {

return uniRunStage(screenExecutor(executor), action);

}

带有Async的都是异步的，就是另外开一个线程，不带的都是和上一个线程公用一个线程

thenRun测试

thenRun:没有返回值，不能过去到上个任务的执行结果

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println("主线程启动");

CompletableFuture future = CompletableFuture.supplyAsync(() -> {

int i = 10 / 2;

System.out.println("任务一执行完成");

return i;

}, executor).thenRunAsync(() -> {

System.out.println("任务二执行完成");

}, executor);

System.out.println("主线程结束");

}

thenAccept测试

thenAccept：可以获取到上一任务的执行结果，没有返回值

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println("主线程启动");

CompletableFuture future = CompletableFuture.supplyAsync(() -> {

int i = 10 / 2;

System.out.println("任务一执行完成");

return i;

}, executor).thenAcceptAsync(res -> {

System.out.println("任务一执行结果："+res);

},executor);

System.out.println("主线程结束");

}

thenApply测试

thenApply：可以接收到上一个任务的执行结果，并且也有返回值

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println("主线程启动");

CompletableFuture future = CompletableFuture.supplyAsync(() -> {

int i = 10 / 2;

System.out.println("任务一执行完成");

return i;

}, executor).thenApplyAsync(res -> {

System.out.println("任务一执行结果：" + res);

return res;

}, executor);

System.out.println(future.get());

System.out.println("主线程结束");

}

两个任务组合，都要完成

当两个CompletableFuture组合完成之后，如果还需继续执行其他任务，可以使用任务组合,必须等待前两个任务执行完才能继续执行

runAfterBoth()：当两个任务执行完成之后，继续执行第三个任务，不能获取其他任务的返回结果，没有返回值

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println("主线程启动");

CompletableFuture future = CompletableFuture.supplyAsync(() -> {

int i = 10 / 2;

System.out.println("任务一执行完成");

return i;

}, executor);

CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {

System.out.println("任务二执行完成");

return "hello world";

});

CompletableFuture voidCompletableFuture = future.runAfterBothAsync(future1, () -> {

System.out.println("任务三执行完成");

}, executor);

System.out.println(future.get());

System.out.println("主线程结束");

}

thenAcceptBoth():当两个任务执行完成之后，继续执行第三个任务，可以获取前两个任务的执行结果，没有返回值

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println("主线程启动");

CompletableFuture future = CompletableFuture.supplyAsync(() -> {

int i = 10 / 2;

System.out.println("任务一执行完成");

return i;

}, executor);

CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {

System.out.println("任务二执行完成");

return "hello world";

});

CompletableFuture voidCompletableFuture = future.thenAcceptBothAsync(future1, (f1,f2) -> {

System.out.println("任务一的执行结果："+f1);

System.out.println("任务二的执行结果："+f2);

System.out.println("任务三执行完成");

}, executor);

System.out.println(future.get());

System.out.println("主线程结束");

}

thenCombine()：当两个任务执行完成之后，继续执行第三个任务，可以获取前两个任务的执行结果，有返回值

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println("主线程启动");

CompletableFuture future = CompletableFuture.supplyAsync(() -> {

int i = 10 / 2;

System.out.println("任务一执行完成");

return i;

}, executor);

CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {

System.out.println("任务二执行完成");

return "hello world";

});

CompletableFuture future2 = future.thenCombineAsync(future1, (f1, f2) -> {

System.out.println("任务一的执行结果：" + f1);

System.out.println("任务二的执行结果：" + f2);

System.out.println("任务三执行完成");

return f1 + f2;

}, executor);

System.out.println("任务三执行结果"+future2.get());

System.out.println("主线程结束");

}

两个任务组合，一个完成

当两个CompletableFuture组合完成之后，如果还需继续执行其他任务，可以使用任务组合,只需等待两个中的其中一个执行完成，就可以执行其他任务

runAfterEither()：当两个任务其中一个执行完成之后，就执行第三个任务，不能获取其他任务的返回结果，没有返回值 acceptEither()：当两个任务其中一个执行完成之后，就执行第三个任务，可以获取其他任务的返回结果，没有返回值 acceptEither()：当两个任务其中一个执行完成之后，就执行第三个任务，可以获取其他任务的返回结果，有返回值

多任务组合

CompletableFuture.allOf(future, future1)：等待所有的任务执行完成 CompletableFuture.anyOf()：只要有一个任务执行完就结束

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println("主线程启动---"+ LocalDateTime.now());

CompletableFuture future = CompletableFuture.runAsync(() -> {

System.out.println("任务一执行完成");

}, executor);

CompletableFuture future1 = CompletableFuture.runAsync(() -> {

try {

Thread.sleep(3000L);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("任务二执行完成");

}, executor);

CompletableFuture allOf = CompletableFuture.allOf(future, future1);

allOf.get();//等待所有任务执行完

System.out.println("主线程结束---"+ LocalDateTime.now());

}

优惠劵

qq_43659061

关注

踩

觉得还不错?

一键收藏

知道了

JAVA 多线程、CompleableFuture异步编程

初始化线程的四种办法继承Thread类实现Rannable 接口实现callable 接口 + FutureTask （可以获取处理结果和处理异常）线程池继承Thread实现public class ThreadTest { public static void main(String[] args) { System.out.println("主线程启动"); Thread1 thread1 = new Thread1(); thre

复制链接

扫一扫

主线程等待子线程结束代码

10-14

我在工作的过程中遇到一个问题,需要主线程等等所有子线程执行完后再做某件事情,在网上找了很多代码,都没有真正解决这个问题.

现在我解决了这个问题,把代码共享出来供大家参考.

代码中有注释和注意事项,相信大家看过后就会觉得非常简单.

Java8 CompletableFuture底层实现及使用详解

程序员野蛮成长

07-14

586

该方法的区别在于，它将任务串联起来，可以实现多个异步操作的链式调用。然后，通过thenApply方法将该CompletableFuture对象转换为一个新的CompletableFuture对象，用于异步执行一个返回整数类型的任务，转换函数是将字符串长度作为结果返回。thenCompose方法接收一个Function类型的参数，该函数用于将一个CompletableFuture对象的结果作为下一个CompletableFuture对象的输入，并返回一个新的CompletableFuture对象。

参与评论

您还未登录，请先

后发表或查看评论

Java CompletableFuture 详解

橙子wj的博客

05-21

2605

出处：

http://colobu.com/2016/02/29/Java-CompletableFuture/Future是Java 5添加的类，用来描述一个异步计算的结果。你可以使用isDone方法检查计算是否完成，或者使用get阻塞住调用线程，直到计算完成返回结果，你也可以使用cancel方法停止任务的执行。虽然Future以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不

Java8特性 - CompletableFuture的基础使用

Zong_0915的博客

10-19

1137

Java8特性 - CompletableFuture的基础使用

Qt之QThread介绍(常用接口及实现、自动释放内存、关闭窗口时停止线程运行、同步互斥)

comp（计算机命令）_百度百科

（计算机命令）_百度百科网页新闻贴吧知道网盘图片视频地图文库资讯采购百科百度首页登录注册进入词条全站搜索帮助首页秒懂百科特色百科知识专题加入百科百科团队权威合作下载百科APP个人中心COMP是一个多义词，请在下列义项上选择浏览（共3个义项）添加义项收藏查看我的收藏0有用+10comp播报讨论上传视频计算机命令Comp逐字节地比较两个文件或几组文件的内容。Comp 可以比较相同驱动器或不同驱动器上的文件以及相同目录或不同目录中的文件。comp 比较文件时，它将显示文件的位置和文件名。如果在不含参数的情况下使用，则 comp 提示输入要进行比较的文件。外文名comp属性计算机命令目录1语法2参数3注释▪比较相同名称的文件▪data1 和 data2 的特殊情形▪comp 命令如何标识不匹配信息▪按顺序比较文件4范例语法播报编辑comp [data1] [data2] [/d] [/a] [/l] [/n=number] [/c]参数播报编辑data1指定要比较的第一个文件或文件集的位置和名称。使用通配字符（* 和 ?）可以指定多个文件。data2指定要比较的第二个文件或文件集的位置和名称。使用通配字符（* 和 ?）可以指定多个文件。/d用十进制格式显示差别。（默认格式为十六进制。）/a将差别显示为字符形式。/l显示出现差别的行编号，而不显示字节偏量。/n=number比较两个文件的第一个 number，即使两个文件的大小并不相同。/c执行不区分大小写的比较。/off[line]处理设置了脱机属性的文件。/?在命令提示符显示帮助。 [1]注释播报编辑比较相同名称的文件如果要比较的文件位于不同的目录或不同的驱动器，则它们可以有相同的文件名。如果不为 data2 指定文件名，则 data2 的默认文件名与 data1 中的文件名相同。可以使用通配字符（* 和 ?）来指定文件名。data1 和 data2 的特殊情形如果省略 data1 或 data2 的必要组件或者省略 data2，comp 将提示您输入缺少的信息。如果 data1 只包含驱动器号或没有文件名的目录名，则 comp 将对指定目录中的所有文件和 data2 中指定的文件进行比较。如果 data2 只包含驱动器号或目录名，则 data2 的默认文件名与 data1 中的相同。comp 命令如何标识不匹配信息在比较期间，comp 会显示消息，标识两个文件中不同信息的位置。每条消息都表明了不相等字节的偏移内存地址和字节本身的内容（除非指定了 /a 或 /d 命令行选项，否则都用十六进制记数法表示）。消息按以下格式显示： [1]Compare error at OFFSET xxxxxxxx

file1 = xx

file2 = xx经过 10 个不相等的比较后，comp 命令终止了文件对比并显示出下列信息：10 Mismatches - ending compare

Comparing files of different sizes除非指定 /n 命令行选项，否则不能比较不同大小的文件。如果文件大小不同，comp 将显示下列消息：Files are different sizes

Compare more files (Y/N)?按 Y 比较其他文件对。按 N 停止 comp 命令。如果按 Y 来响应提示，则 comp 在其所作的每个比较中都将使用在命令行中指定的任意命令行选项，直到按下 N 或重新键入命令。在比较不同大小的文件时，使用 /n 命令行选项将仅比较每个文件的第一部分。按顺序比较文件如果使用通配符（* 和 ?）指定多个文件，comp 查找与 data1 匹配的第一个文件，并将它与 data2 中的相应文件（如果有的话）进行比较。comp 命令报告比较结果，然后对每个匹配 data1 的文件进行相同的操作。完成后，comp 显示下列消息：Compare more files (Y/N)?要比较其他文件，请按 Y。comp 命令提示符您键入新文件的位置和名称。要停止比较，请按 N。当按下 Y 时，comp 将提示您输入要使用的命令行选项。如果未指定任何命令行选项，comp 将使用以前指定的命令行选项。如果 comp 无法找到文件，将使用消息提示您决定是否要比较其他文件。范例播报编辑要将目录 C:\Reports 的内容与备份目录\\Sales\Backup\April进行比较，请键入：comp c:\reports\\sales\backup\april要比较 \Invoice 目录中文本文件的开头 10 行并以十进制格式显示结果，请键入：comp \invoice\*.txt \invoice\backup\*.txt /n=10 /d新手上路成长任务编辑入门编辑规则本人编辑我有疑问内容质疑在线客服官方贴吧意见反馈投诉建议举报不良信息未通过词条申诉投诉侵权信息封禁查询与解封©2024 Baidu 使用百度前必读 | 百科协议 | 隐私政策 | 百度百科合作平台 | 京ICP证030173号京公网安备110000020000

comp是什么意思_comp的翻译_音标_读音_用法_例句_爱词霸在线词典

是什么意思_comp的翻译_音标_读音_用法_例句_爱词霸在线词典首页翻译背单词写作校对词霸下载用户反馈专栏平台登录comp是什么意思_comp用英语怎么说_comp的翻译_comp翻译成_comp的中文意思_comp怎么读,comp的读音,comp的用法,comp的例句翻译人工翻译试试人工翻译翻译全文comp英 [kɒmp]美 [kɑmp]释义n.补偿，赔偿; 赠品大小写变形:COMPCoMPComp点击人工翻译，了解更多人工释义词态变化复数: comps;实用场景例句全部Her children go to the local comp.她的孩子们上当地的综合中学。《牛津高阶英汉双解词典》In the matter of " comp'ny " Mammy was equally adamant.嬷嬷在住宿方面的态度也一样坚决.飘（部分）D - COMP possesses both evaluative and statistical functions.comp具有测评和统计双重功能.互联网The chemotherapy regimen consisted of 2～8 cycles of COP, COMP, CHOP or BACOP regimen.放疗前、中、后行COP 、 comp 、 CHOP、BACOP方案化疗2～8个疗程.互联网Traditionally , the largest set of newsgroups has been the computer - related ones under the hierarchy comp.历来最大的一组专题组是comp级下的与计算机有关的专题组.互联网Qu é saben lo que es tango , qu é saben de comp á s!什么叫神气活现, 削瘦的时尚男女最懂!互联网Sticking pipe has been being a comp 1 icated problem in drilling this area.在这个地区打井卡钻一直是个复杂问题.互联网I work for an IT comp any. I'm a consultant.在一家IT公司工作, 是一名顾问.互联网COMP Compares the contents of two files or sets of files.比较两个或两组档的内容.互联网He peered at the comp - uter screen, wondering what his programming mistake was.他仔细地看着计算机的显示屏, 想知道他的程序出了什么错.互联网Lors de ces 29è me Olympiades, la comp é tition s'annonce particuli è rement disput é e.第29奥运会上的竞争会更为激烈.互联网Comp : I have never seen such a wonderful park before.我从来未看见过这样漂亮的公园.互联网The major comp lications encountered were cataract, corneal scar and glaucoma.并发症主要包括白内障、角膜疤痕、青光眼.互联网Comp : Tom did not speak a single word.汤姆一句话也不说.互联网Ainsi, nous deviendrons plus comp é titifs, plus innovants.这样我们才会最具竞争力, 最具创造力.互联网收起实用场景例句释义词态变化实用场

COMP中文(繁體)翻譯：劍橋詞典

詞典

翻譯

文法

同義詞詞典

+Plus

劍橋詞典+Plus

Shop

劍橋詞典+Plus

我的主頁

+Plus 幫助

退出

劍橋詞典+Plus

我的主頁

+Plus 幫助

退出

登錄

註冊

正體中文 (繁體)

查找

英語-中文（繁體）

comp 在英語-中文（繁體）詞典中的翻譯

compverb [ T ] mainly US informal uk

Your browser doesn't support HTML5 audio

/kɒmp/ us

Your browser doesn't support HTML5 audio

/kɑːmp/

Add to word list

to give someone something valuable without asking for payment

饋贈，贈送

Usually, the writer's entire trip is comped.

一般來說作者全部旅程的費用都是全包的。

They comped us two tickets.

他們贈送我們兩張票。

comped meals/drinks

饋贈的飯／飲料

to allow someone to do something without having to pay

讓…不花錢（做某件事）

You can comp two guests.

你可以免費帶兩個客人來。

(comp在劍橋英語-中文（繁體）詞典的翻譯 © Cambridge University Press)

comp的例句

comp

During a drum solo the pianist sometimes comps, often using a predictable pattern of rhythmically-played chords called hits.

來自 Wikipedia

該例句來自維基百科，在CC BY-SA許可下可重複使用。

High rollers often receive lavish comps from casinos to lure them onto the gambling floors, such as free private jet transfers, limousine use and use of the casinos' best suites.

來自 Wikipedia

該例句來自維基百科，在CC BY-SA許可下可重複使用。

There was a number of reasons for the school to be the first comp.

來自 Wikipedia

該例句來自維基百科，在CC BY-SA許可下可重複使用。

The comp works by diverting gases at the muzzle.

來自 Wikipedia

該例句來自維基百科，在CC BY-SA許可下可重複使用。

Casinos are permitted to give away comp drinks, and many do to reward and encourage gambling.

來自 Wikipedia

該例句來自維基百科，在CC BY-SA許可下可重複使用。

We also prove that it is equivalent to 1 for a class of programs involving tautologies, which we will define as tau-comp.

來自 Cambridge English Corpus

The amount of comps that a player is given usually depends on what game they play, how much they bet, and how long they play.

來自 Wikipedia

該例句來自維基百科，在CC BY-SA許可下可重複使用。

An artists proof is also known as a comp or complimentary if given to printers.

來自 Wikipedia

該例句來自維基百科，在CC BY-SA許可下可重複使用。

示例中的觀點不代表劍橋詞典編輯、劍橋大學出版社和其許可證頒發者的觀點。

comp的翻譯

中文（簡體）

馈赠，赠送, 让…不花钱（做某件事）…

查看更多內容

西班牙語

forma abreviada de "competition":, competición, concurso…

查看更多內容

葡萄牙語

oferecer como cortesia, compensação, remuneração…

查看更多內容

需要一個翻譯器嗎？

獲得快速、免費的翻譯！

翻譯器工具

comp的發音是什麼？

在英語詞典中查看 comp 的釋義

瀏覽

Comoran

comorbid

comorbidity

Comoros

comp

comp time

compact

compact disc

compaction

comp更多的中文(繁體)翻譯

全部

comp time

fully comp

comp time, at compensatory time

查看全部意思»

「每日一詞」

veggie burger

Your browser doesn't support HTML5 audio

/ˈvedʒ.i ˌbɜː.ɡər/

Your browser doesn't support HTML5 audio

/ˈvedʒ.i ˌbɝː.ɡɚ/

a type of food similar to a hamburger but made without meat, by pressing together small pieces of vegetables, seeds, etc. into a flat, round shape

關於這個

部落格

Forget doing it or forget to do it? Avoiding common mistakes with verb patterns (2)

March 06, 2024

新詞

stochastic parrot

March 04, 2024

已添加至 list

回到頁面頂端

內容

英語-中文（繁體）例句翻譯

©劍橋大學出版社與評估2024

學習

新詞

幫助

紙本出版

Word of the Year 2021

Word of the Year 2022

Word of the Year 2023

開發

詞典API

連按兩下查看

搜尋Widgets

執照資料

關於

無障礙閱讀

劍橋英語教學

劍橋大學出版社與評估

授權管理

Cookies與隱私保護

語料庫

使用條款

京ICP备14002226号-2

©劍橋大學出版社與評估2024

劍橋詞典+Plus

我的主頁

+Plus 幫助

退出

詞典

定義

清晰解釋自然的書面和口頭英語

英語

學習詞典

基礎英式英語

基礎美式英語

翻譯

點選箭頭改變翻譯方向。

雙語詞典

英語-中文（簡體）

Chinese (Simplified)–English

英語-中文（繁體）

Chinese (Traditional)–English

英語-荷蘭文

荷蘭語-英語

英語-法語

法語-英語

英語-德語

德語-英語

英語-印尼語

印尼語-英語

英語-義大利語

義大利語-英語

英語-日語

日語-英語

英語-挪威語

挪威語-英語

英語-波蘭語

波蘭語-英語

英語-葡萄牙語

葡萄牙語-英語

英語-西班牙語

西班牙語-英語

English–Swedish

Swedish–English

半雙語詞典

英語-阿拉伯語

英語-孟加拉文

英語-加泰羅尼亞語

英語-捷克語

英語-丹麥語

English–Gujarati

英語-印地語

英語-韓語

英語-馬來語

英語-馬拉地語

英語-俄語

English–Tamil

English–Telugu

英語-泰語

英語-土耳其語

英語-烏克蘭文

English–Urdu

英語-越南語

翻譯

文法

同義詞詞典

Pronunciation

劍橋詞典+Plus

Shop

劍橋詞典+Plus

我的主頁

+Plus 幫助

退出

登錄 /

註冊

正體中文 (繁體)

Change

English (UK)

English (US)

Español

Русский

Português

Deutsch

Français

Italiano

中文 (简体)

正體中文 (繁體)

Polski

한국어

Türkçe

日本語

Tiếng Việt

हिंदी

தமிழ்

తెలుగు

關注我們！

選擇一本詞典

Java 8 的异步编程利器 CompletableFuture 详解_java8 completablefuture-CSDN博客

Java 8 的异步编程利器 CompletableFuture 详解

ThinkWon

已于 2022-03-09 23:34:13 修改

阅读量4.3k

点赞数

分类专栏：

并发编程

文章标签：

异步编程利器

Java 8 的异步编程利器

于 2022-03-09 23:32:24 首次发布

本文链接：https://blog.csdn.net/ThinkWon/article/details/123390393

版权

并发编程

专栏收录该内容

33 篇文章

127 订阅

订阅专栏

文章目录

一个例子回顾 Future一个例子走进CompletableFutureCompletableFuture使用场景创建异步任务supplyAsync方法runAsync方法

任务异步回调1. thenRun/thenRunAsync2.thenAccept/thenAcceptAsync3. thenApply/thenApplyAsync4. exceptionally5. whenComplete方法6. handle方法

多个任务组合处理AND组合关系OR组合的关系AllOfAnyOfthenCompose

CompletableFuture使用有哪些注意点1. Future需要获取返回值，才能获取异常信息2. CompletableFuture的get()方法是阻塞的3. 默认线程池的注意点4. 自定义线程池时，注意饱和策略

最近刚好使用CompeletableFuture优化了项目中的代码，所以跟大家一起学习CompletableFuture

一个例子回顾 Future

因为CompletableFuture实现了Future接口，我们先来回顾Future吧

Future是Java5新加的一个接口，它提供了一种异步并行计算的功能。如果主线程需要执行一个很耗时的计算任务，我们就可以通过future把这个任务放到异步线程中执行。主线程继续处理其他任务，异步线程处理完成后，再通过Future获取计算结果

来看个简单例子吧，假设我们有两个任务服务，一个查询用户基本信息，一个是查询用户勋章信息。如下

public class UserInfoService {

public UserInfo getUserInfo(Long userId) throws InterruptedException {

Thread.sleep(300);//模拟调用耗时

return new UserInfo("666", "技术人成长之路", 27); //一般是查数据库，或者远程调用返回的

}

public class MedalService {

public MedalInfo getMedalInfo(long userId) throws InterruptedException {

Thread.sleep(500); //模拟调用耗时

return new MedalInfo("666", "守护勋章");

}

接下来，我们来演示下，在主线程中是如何使用Future来进行异步调用的。

public class FutureTest {

public static void main(String[] args) throws ExecutionException, InterruptedException {

ExecutorService executorService = Executors.newFixedThreadPool(10);

UserInfoService userInfoService = new UserInfoService();

MedalService medalService = new MedalService();

long userId =666L;

long startTime = System.currentTimeMillis();

//调用用户服务获取用户基本信息

FutureTask userInfoFutureTask = new FutureTask<>(new Callable() {

@Override

public UserInfo call() throws Exception {

return userInfoService.getUserInfo(userId);

}

});

executorService.submit(userInfoFutureTask);

Thread.sleep(300); //模拟主线程其它操作耗时

FutureTask medalInfoFutureTask = new FutureTask<>(new Callable() {

@Override

public MedalInfo call() throws Exception {

return medalService.getMedalInfo(userId);

}

});

executorService.submit(medalInfoFutureTask);

UserInfo userInfo = userInfoFutureTask.get();//获取个人信息结果

MedalInfo medalInfo = medalInfoFutureTask.get();//获取勋章信息结果

System.out.println("总共用时" + (System.currentTimeMillis() - startTime) + "ms");

}

运行结果:

总共用时806ms

如果我们不使用Future进行并行异步调用，而是在主线程串行进行的话，耗时大约为300+500+300 = 1100 ms。可以发现，future+线程池异步配合，提高了程序的执行效率。

但是Future对于结果的获取，不是很友好，只能通过阻塞或者轮询的方式得到任务的结果。

Future.get() 就是阻塞调用，在线程获取结果之前get方法会一直阻塞。Future提供了一个isDone方法，可以在程序中轮询这个方法查询执行结果。

阻塞的方式和异步编程的设计理念相违背，而轮询的方式会耗费无谓的CPU资源。因此，JDK8设计出CompletableFuture。CompletableFuture提供了一种观察者模式类似的机制，可以让任务执行完成后通知监听的一方。

一个例子走进CompletableFuture

我们还是基于以上Future的例子，改用CompletableFuture 来实现

public class FutureTest {

public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {

UserInfoService userInfoService = new UserInfoService();

MedalService medalService = new MedalService();

long userId =666L;

long startTime = System.currentTimeMillis();

//调用用户服务获取用户基本信息

CompletableFuture completableUserInfoFuture = CompletableFuture.supplyAsync(() -> userInfoService.getUserInfo(userId));

Thread.sleep(300); //模拟主线程其它操作耗时

CompletableFuture completableMedalInfoFuture = CompletableFuture.supplyAsync(() -> medalService.getMedalInfo(userId));

UserInfo userInfo = completableUserInfoFuture.get(2,TimeUnit.SECONDS);//获取个人信息结果

MedalInfo medalInfo = completableMedalInfoFuture.get();//获取勋章信息结果

System.out.println("总共用时" + (System.currentTimeMillis() - startTime) + "ms");

}

可以发现，使用CompletableFuture，代码简洁了很多。CompletableFuture的supplyAsync方法，提供了异步执行的功能，线程池也不用单独创建了。实际上，它CompletableFuture使用了默认线程池是ForkJoinPool.commonPool。

CompletableFuture提供了几十种方法，辅助我们的异步任务场景。这些方法包括创建异步任务、任务异步回调、多个任务组合处理等方面。我们一起来学习吧

CompletableFuture使用场景

创建异步任务

CompletableFuture创建异步任务，一般有supplyAsync和runAsync两个方法

创建异步任务

supplyAsync执行CompletableFuture任务，支持返回值runAsync执行CompletableFuture任务，没有返回值。

supplyAsync方法

//使用默认内置线程池ForkJoinPool.commonPool()，根据supplier构建执行任务

public static CompletableFuture supplyAsync(Supplier supplier)

//自定义线程，根据supplier构建执行任务

public static CompletableFuture supplyAsync(Supplier supplier, Executor executor)

runAsync方法

//使用默认内置线程池ForkJoinPool.commonPool()，根据runnable构建执行任务

public static CompletableFuture runAsync(Runnable runnable)

//自定义线程，根据runnable构建执行任务

public static CompletableFuture runAsync(Runnable runnable, Executor executor)

实例代码如下：

public class FutureTest {

public static void main(String[] args) {

//可以自定义线程池

ExecutorService executor = Executors.newCachedThreadPool();

//runAsync的使用

CompletableFuture runFuture = CompletableFuture.runAsync(() -> System.out.println("run,技术人成长之路"), executor);

//supplyAsync的使用

CompletableFuture supplyFuture = CompletableFuture.supplyAsync(() -> {

System.out.print("supply,技术人成长之路");

return "技术人成长之路"; }, executor);

//runAsync的future没有返回值，输出null

System.out.println(runFuture.join());

//supplyAsync的future，有返回值

System.out.println(supplyFuture.join());

executor.shutdown(); // 线程池需要关闭

}

//输出

run,技术人成长之路

null

supply,技术人成长之路技术人成长之路

任务异步回调

1. thenRun/thenRunAsync

public CompletableFuture thenRun(Runnable action);

public CompletableFuture thenRunAsync(Runnable action);

CompletableFuture的thenRun方法，通俗点讲就是，做完第一个任务后，再做第二个任务。某个任务执行完成后，执行回调方法；但是前后两个任务没有参数传递，第二个任务也没有返回值

public class FutureThenRunTest {

public static void main(String[] args) throws ExecutionException, InterruptedException {

CompletableFuture orgFuture = CompletableFuture.supplyAsync(

()->{

System.out.println("先执行第一个CompletableFuture方法任务");

return "技术人成长之路";

}

);

CompletableFuture thenRunFuture = orgFuture.thenRun(() -> {

System.out.println("接着执行第二个任务");

});

System.out.println(thenRunFuture.get());

}

//输出

先执行第一个CompletableFuture方法任务

接着执行第二个任务

null

thenRun 和 thenRunAsync 有什么区别呢？可以看下源码哈：

private static final Executor asyncPool = useCommonPool ?

ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();

public CompletableFuture thenRun(Runnable action) {

return uniRunStage(null, action);

}

public CompletableFuture thenRunAsync(Runnable action) {

return uniRunStage(asyncPool, action);

}

如果你执行第一个任务的时候，传入了一个自定义线程池：

调用thenRun方法执行第二个任务时，则第二个任务和第一个任务是共用同一个线程池。调用thenRunAsync方法执行第二个任务时，则第一个任务使用的是你自己传入的线程池，第二个任务使用的是ForkJoin线程池

TIPS：后面介绍的thenAccept和thenAcceptAsync，thenApply和thenApplyAsync等，它们之间的区别也是这个哈。

2.thenAccept/thenAcceptAsync

CompletableFuture的thenAccept方法表示，第一个任务执行完成后，执行第二个回调方法任务，会将第一个任务的执行结果，作为第二个任务的入参，传递到回调方法中，但是回调方法是没有返回值的。

public class FutureThenAcceptTest {

public static void main(String[] args) throws ExecutionException, InterruptedException {

CompletableFuture orgFuture = CompletableFuture.supplyAsync(

()->{

System.out.println("原始CompletableFuture方法任务");

return "技术人成长之路";

}

);

CompletableFuture thenAcceptFuture = orgFuture.thenAccept((a) -> {

if ("技术人成长之路".equals(a)) {

System.out.println("关注了");

}

System.out.println("先考虑考虑");

});

System.out.println(thenAcceptFuture.get());

}

3. thenApply/thenApplyAsync

CompletableFuture的thenApply方法表示，第一个任务执行完成后，执行第二个回调方法任务，会将第一个任务的执行结果，作为第二个任务的入参，传递到回调方法中，并且回调方法是有返回值的。

public class FutureThenApplyTest {

public static void main(String[] args) throws ExecutionException, InterruptedException {

CompletableFuture orgFuture = CompletableFuture.supplyAsync(

()->{

System.out.println("原始CompletableFuture方法任务");

return "技术人成长之路";

}

);

CompletableFuture thenApplyFuture = orgFuture.thenApply((a) -> {

if ("技术人成长之路".equals(a)) {

return "关注了";

}

return "先考虑考虑";

});

System.out.println(thenApplyFuture.get());

}

//输出

原始CompletableFuture方法任务

关注了

4. exceptionally

CompletableFuture的exceptionally方法表示，某个任务执行异常时，执行的回调方法；并且有抛出异常作为参数，传递到回调方法。

public class FutureExceptionTest {

public static void main(String[] args) throws ExecutionException, InterruptedException {

CompletableFuture orgFuture = CompletableFuture.supplyAsync(

()->{

System.out.println("当前线程名称：" + Thread.currentThread().getName());

throw new RuntimeException();

}

);

CompletableFuture exceptionFuture = orgFuture.exceptionally((e) -> {

e.printStackTrace();

return "你的程序异常啦";

});

System.out.println(exceptionFuture.get());

}

//输出

当前线程名称：ForkJoinPool.commonPool-worker-1

java.util.concurrent.CompletionException: java.lang.RuntimeException

at java.util.concurrent.CompletableFuture.encodeThrowable(CompletableFuture.java:273)

at java.util.concurrent.CompletableFuture.completeThrowable(CompletableFuture.java:280)

at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1592)

at java.util.concurrent.CompletableFuture$AsyncSupply.exec(CompletableFuture.java:1582)

at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)

at java.util.concurrent.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1056)

at java.util.concurrent.ForkJoinPool.runWorker(ForkJoinPool.java:1692)

at java.util.concurrent.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:157)

Caused by: java.lang.RuntimeException

at cn.eovie.future.FutureWhenTest.lambda$main$0(FutureWhenTest.java:13)

at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1590)

... 5 more

你的程序异常啦

5. whenComplete方法

CompletableFuture的whenComplete方法表示，某个任务执行完成后，执行的回调方法，无返回值；并且whenComplete方法返回的CompletableFuture的result是上个任务的结果。

public class FutureWhenTest {

public static void main(String[] args) throws ExecutionException, InterruptedException {

CompletableFuture orgFuture = CompletableFuture.supplyAsync(

()->{

System.out.println("当前线程名称：" + Thread.currentThread().getName());

try {

Thread.sleep(2000L);

} catch (InterruptedException e) {

e.printStackTrace();

}

return "技术人成长之路";

}

);

CompletableFuture rstFuture = orgFuture.whenComplete((a, throwable) -> {

System.out.println("当前线程名称：" + Thread.currentThread().getName());

System.out.println("上个任务执行完啦，还把" + a + "传过来");

if ("技术人成长之路".equals(a)) {

System.out.println("666");

}

System.out.println("233333");

});

System.out.println(rstFuture.get());

}

//输出

当前线程名称：ForkJoinPool.commonPool-worker-1

上个任务执行完啦，还把技术人成长之路传过来

666

233333

技术人成长之路

6. handle方法

CompletableFuture的handle方法表示，某个任务执行完成后，执行回调方法，并且是有返回值的；并且handle方法返回的CompletableFuture的result是回调方法执行的结果。

public class FutureHandlerTest {

public static void main(String[] args) throws ExecutionException, InterruptedException {

CompletableFuture orgFuture = CompletableFuture.supplyAsync(

()->{

System.out.println("当前线程名称：" + Thread.currentThread().getName());

try {

Thread.sleep(2000L);

} catch (InterruptedException e) {

e.printStackTrace();

}

return "技术人成长之路";

}

);

CompletableFuture rstFuture = orgFuture.handle((a, throwable) -> {

System.out.println("上个任务执行完啦，还把" + a + "传过来");

if ("技术人成长之路".equals(a)) {

System.out.println("666");

return "关注了";

}

System.out.println("233333");

return null;

});

System.out.println(rstFuture.get());

}

//输出

当前线程名称：ForkJoinPool.commonPool-worker-1

上个任务执行完啦，还把技术人成长之路传过来

666

关注了

多个任务组合处理

AND组合关系

thenCombine / thenAcceptBoth / runAfterBoth都表示：将两个CompletableFuture组合起来，只有这两个都正常执行完了，才会执行某个任务。

区别在于：

thenCombine：会将两个任务的执行结果作为方法入参，传递到指定方法中，且有返回值thenAcceptBoth: 会将两个任务的执行结果作为方法入参，传递到指定方法中，且无返回值runAfterBoth：不会把执行结果当做方法入参，且没有返回值。

public class ThenCombineTest {

public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {

CompletableFuture first = CompletableFuture.completedFuture("第一个异步任务");

ExecutorService executor = Executors.newFixedThreadPool(10);

CompletableFuture future = CompletableFuture

//第二个异步任务

.supplyAsync(() -> "第二个异步任务", executor)

// (w, s) -> System.out.println(s) 是第三个任务

.thenCombineAsync(first, (s, w) -> {

System.out.println(w);

System.out.println(s);

return "两个异步任务的组合";

}, executor);

System.out.println(future.join());

executor.shutdown();

}

//输出

第一个异步任务

第二个异步任务

两个异步任务的组合

OR组合的关系

applyToEither / acceptEither / runAfterEither 都表示：将两个CompletableFuture组合起来，只要其中一个执行完了，就会执行某个任务。

区别在于：

applyToEither：会将已经执行完成的任务，作为方法入参，传递到指定方法中，且有返回值acceptEither: 会将已经执行完成的任务，作为方法入参，传递到指定方法中，且无返回值runAfterEither：不会把执行结果当做方法入参，且没有返回值。

public class AcceptEitherTest {

public static void main(String[] args) {

//第一个异步任务，休眠2秒，保证它执行晚点

CompletableFuture first = CompletableFuture.supplyAsync(()->{

try{

Thread.sleep(2000L);

System.out.println("执行完第一个异步任务");}

catch (Exception e){

return "第一个任务异常";

}

return "第一个异步任务";

});

ExecutorService executor = Executors.newSingleThreadExecutor();

CompletableFuture future = CompletableFuture

//第二个异步任务

.supplyAsync(() -> {

System.out.println("执行完第二个任务");

return "第二个任务";}

, executor)

//第三个任务

.acceptEitherAsync(first, System.out::println, executor);

executor.shutdown();

}

//输出

执行完第二个任务

第二个任务

AllOf

所有任务都执行完成后，才执行 allOf 返回的CompletableFuture。如果任意一个任务异常，allOf的CompletableFuture，执行get方法，会抛出异常

public class allOfFutureTest {

public static void main(String[] args) throws ExecutionException, InterruptedException {

CompletableFuture a = CompletableFuture.runAsync(()->{

System.out.println("我执行完了");

});

CompletableFuture b = CompletableFuture.runAsync(() -> {

System.out.println("我也执行完了");

});

CompletableFuture allOfFuture = CompletableFuture.allOf(a, b).whenComplete((m,k)->{

System.out.println("finish");

});

}

//输出

我执行完了

我也执行完了

finish

AnyOf

任意一个任务执行完，就执行anyOf返回的CompletableFuture。如果执行的任务异常，anyOf的CompletableFuture，执行get方法，会抛出异常

public class AnyOfFutureTest {

public static void main(String[] args) throws ExecutionException, InterruptedException {

CompletableFuture a = CompletableFuture.runAsync(()->{

try {

Thread.sleep(3000L);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("我执行完了");

});

CompletableFuture b = CompletableFuture.runAsync(() -> {

System.out.println("我也执行完了");

});

CompletableFuture

imtoken钱包官方版下载安卓版|comp

imtoken钱包官方版下载安卓版|comp

COMP中文(简体)翻译：剑桥词典

JAVA 多线程、CompleableFuture异步编程_java compositefuture-CSDN博客

comp（计算机命令）_百度百科

comp是什么意思_comp的翻译_音标_读音_用法_例句_爱词霸在线词典

COMP中文(繁體)翻譯：劍橋詞典

Java 8 的异步编程利器 CompletableFuture 详解_java8 completablefuture-CSDN博客

Java并发编程之CompletableFuture详解_java completablefuture-CSDN博客

Homepage of Chensong Zhang's webpage

北京的各个行政区都有什么特点？ - 知乎

菜单

支持

Follow

imtoken钱包官方版下载安卓版|comp

imtoken钱包官方版下载安卓版|comp

COMP中文(简体)翻译：剑桥词典

JAVA 多线程、CompleableFuture异步编程_java compositefuture-CSDN博客

comp（计算机命令）_百度百科

comp是什么意思_comp的翻译_音标_读音_用法_例句_爱词霸在线词典

COMP中文(繁體)翻譯：劍橋詞典

Java 8 的异步编程利器 CompletableFuture 详解_java8 completablefuture-CSDN博客

Java并发编程之CompletableFuture详解_java completablefuture-CSDN博客

Homepage of Chensong Zhang's webpage

北京的各个行政区都有什么特点？ - 知乎

最近的新闻

您可能喜欢的文章

tokenpocket钱包下载中文版|cmct

tokenpocket钱包下载中文版安装|ctx

如何在tp钱包添加新钱包

如何查看tp钱包的冷钱包

如何注册tp钱包账户

如何用tp钱包转账

tp钱包如何买babydoge