「runAsync方法」

//使用默認內置線程池ForkJoinPool.commonPool()，根據runnable構建執行任務
publicstaticCompletableFuturerunAsync(Runnablerunnable)
//自定義線程，根據runnable構建執行任務
publicstaticCompletableFuturerunAsync(Runnablerunnable,Executorexecutor)

2、結果獲取的4種方式

對于結果的獲取CompltableFuture類提供了四種方式

//方式一
publicTget()
//方式二
publicTget(longtimeout,TimeUnitunit)
//方式三
publicTgetNow(TvalueIfAbsent)
//方式四
publicTjoin()

說明：

• 「get()和get(long timeout, TimeUnit unit)」 => 在Future中就已經提供了，后者提供超時處理，如果在指定時間內未獲取結果將拋出超時異常
• 「getNow」 => 立即獲取結果不阻塞，結果計算已完成將返回結果或計算過程中的異常，如果未計算完成將返回設定的valueIfAbsent值
• 「join」 => 方法里不會拋出異常

示例：

@Test
publicvoidtestCompletableGet()throwsInterruptedException,ExecutionException{

CompletableFuturecp1=CompletableFuture.supplyAsync(()->{
try{
Thread.sleep(1000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
return"商品A";
});

//getNow方法測試
System.out.println(cp1.getNow("商品B"));

//join方法測試
CompletableFuturecp2=CompletableFuture.supplyAsync((()->1/0));
System.out.println(cp2.join());
System.out.println("-----------------------------------------------------");
//get方法測試
CompletableFuturecp3=CompletableFuture.supplyAsync((()->1/0));
System.out.println(cp3.get());
}

「運行結果」 ：

• 第一個執行結果為 「商品B」 ，因為要先睡上1秒結果不能立即獲取
• join方法獲取結果方法里不會拋異常，但是執行結果會拋異常，拋出的異常為CompletionException
• get方法獲取結果方法里將拋出異常，執行結果拋出的異常為ExecutionException

異步回調方法

1、thenRun/thenRunAsync

通俗點講就是，「做完第一個任務后，再做第二個任務,第二個任務也沒有返回值」 。

示例

@Test
publicvoidtestCompletableThenRunAsync()throwsInterruptedException,ExecutionException{
longstartTime=System.currentTimeMillis();

CompletableFuturecp1=CompletableFuture.runAsync(()->{
try{
//執行任務A
Thread.sleep(600);
}catch(InterruptedExceptione){
e.printStackTrace();
}

});

CompletableFuturecp2=cp1.thenRun(()->{
try{
//執行任務B
Thread.sleep(400);
}catch(InterruptedExceptione){
e.printStackTrace();
}
});

//get方法測試
System.out.println(cp2.get());

//模擬主程序耗時時間
Thread.sleep(600);
System.out.println("總共用時"+(System.currentTimeMillis()-startTime)+"ms");
}

//運行結果
/**
*null
*總共用時1610ms
*/

「thenRun 和thenRunAsync有什么區別呢？」

如果你執行第一個任務的時候，傳入了一個自定義線程池：

• 調用thenRun方法執行第二個任務時，則第二個任務和第一個任務是共用同一個線程池。
• 調用thenRunAsync執行第二個任務時，則第一個任務使用的是你自己傳入的線程池，第二個任務使用的是ForkJoin線程池。

說明: 后面介紹的thenAccept和thenAcceptAsync，thenApply和thenApplyAsync等，它們之間的區別也是這個。

2、thenAccept/thenAcceptAsync

第一個任務執行完成后，執行第二個回調方法任務，會將該任務的執行結果，作為入參 ，傳遞到回調方法中，但是回調方法是沒有返回值的。

示例
@Test
publicvoidtestCompletableThenAccept()throwsExecutionException,InterruptedException{
longstartTime=System.currentTimeMillis();
CompletableFuturecp1=CompletableFuture.supplyAsync(()->{
return"dev";

});
CompletableFuturecp2=cp1.thenAccept((a)->{
System.out.println("上一個任務的返回結果為:"+a);
});

cp2.get();
}

3、 thenApply/thenApplyAsync

表示第一個任務執行完成后，執行第二個回調方法任務，會將該任務的執行結果，作為入參，傳遞到回調方法中，并且回調方法是有返回值的。

示例

@Test
publicvoidtestCompletableThenApply()throwsExecutionException,InterruptedException{
CompletableFuturecp1=CompletableFuture.supplyAsync(()->{
return"dev";

}).thenApply((a)->{
if(Objects.equals(a,"dev")){
return"dev";
}
return"prod";
});

System.out.println("當前環境為:"+cp1.get());

//輸出:當前環境為:dev
}

異常回調

當CompletableFuture的任務不論是正常完成還是出現異常它都會調用 「whenComplete」 這回調函數。

• 「正常完成」 ：whenComplete返回結果和上級任務一致，異常為null；
• 「出現異常」 ：whenComplete返回結果為null，異常為上級任務的異常；

即調用get()時，正常完成時就獲取到結果，出現異常時就會拋出異常，需要你處理該異常。

下面來看看示例

1、只用whenComplete

@Test
publicvoidtestCompletableWhenComplete()throwsExecutionException,InterruptedException{
CompletableFuturefuture=CompletableFuture.supplyAsync(()->{

if(Math.random()0.5){
thrownewRuntimeException("出錯了");
}
System.out.println("正常結束");
return0.11;

}).whenComplete((aDouble,throwable)->{
if(aDouble==null){
System.out.println("whenCompleteaDoubleisnull");
}else{
System.out.println("whenCompleteaDoubleis"+aDouble);
}
if(throwable==null){
System.out.println("whenCompletethrowableisnull");
}else{
System.out.println("whenCompletethrowableis"+throwable.getMessage());
}
});
System.out.println("最終返回的結果="+future.get());
}

正常完成，沒有異常時：

正常結束
whenCompleteaDoubleis0.11
whenCompletethrowableisnull
最終返回的結果=0.11

出現異常時：get()會拋出異常

whenCompleteaDoubleisnull
whenCompletethrowableisjava.lang.RuntimeException:出錯了

java.util.concurrent.ExecutionException:java.lang.RuntimeException:出錯了
atjava.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
atjava.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)

2、whenComplete + exceptionally示例

@Test
publicvoidtestWhenCompleteExceptionally()throwsExecutionException,InterruptedException{
CompletableFuturefuture=CompletableFuture.supplyAsync(()->{
if(Math.random()0.5){
thrownewRuntimeException("出錯了");
}
System.out.println("正常結束");
return0.11;

}).whenComplete((aDouble,throwable)->{
if(aDouble==null){
System.out.println("whenCompleteaDoubleisnull");
}else{
System.out.println("whenCompleteaDoubleis"+aDouble);
}
if(throwable==null){
System.out.println("whenCompletethrowableisnull");
}else{
System.out.println("whenCompletethrowableis"+throwable.getMessage());
}
}).exceptionally((throwable)->{
System.out.println("exceptionally中異常："+throwable.getMessage());
return0.0;
});

System.out.println("最終返回的結果="+future.get());
}

當出現異常時，exceptionally中會捕獲該異常，給出默認返回值0.0。

whenCompleteaDoubleisnull
whenCompletethrowableisjava.lang.RuntimeException:出錯了
exceptionally中異常：java.lang.RuntimeException:出錯了
最終返回的結果=0.0

多任務組合回調

1、AND組合關系

thenCombine / thenAcceptBoth / runAfterBoth都表示：「當任務一和任務二都完成再執行任務三」 。

區別在于：

• 「runAfterBoth」 不會把執行結果當做方法入參，且沒有返回值
• 「thenAcceptBoth」 : 會將兩個任務的執行結果作為方法入參，傳遞到指定方法中，且無返回值
• 「thenCombine」 ：會將兩個任務的執行結果作為方法入參，傳遞到指定方法中，且有返回值

示例

@Test
publicvoidtestCompletableThenCombine()throwsExecutionException,InterruptedException{
//創建線程池
ExecutorServiceexecutorService=Executors.newFixedThreadPool(10);
//開啟異步任務1
CompletableFuturetask=CompletableFuture.supplyAsync(()->{
System.out.println("異步任務1，當前線程是："+Thread.currentThread().getId());
intresult=1+1;
System.out.println("異步任務1結束");
returnresult;
},executorService);

//開啟異步任務2
CompletableFuturetask2=CompletableFuture.supplyAsync(()->{
System.out.println("異步任務2，當前線程是："+Thread.currentThread().getId());
intresult=1+1;
System.out.println("異步任務2結束");
returnresult;
},executorService);

//任務組合
CompletableFuturetask3=task.thenCombineAsync(task2,(f1,f2)->{
System.out.println("執行任務3，當前線程是："+Thread.currentThread().getId());
System.out.println("任務1返回值："+f1);
System.out.println("任務2返回值："+f2);
returnf1+f2;
},executorService);

Integerres=task3.get();
System.out.println("最終結果："+res);
}

「運行結果」

異步任務1，當前線程是：17
異步任務1結束
異步任務2，當前線程是：18
異步任務2結束
執行任務3，當前線程是：19
任務1返回值：2
任務2返回值：2
最終結果：4

2、OR組合關系

applyToEither / acceptEither / runAfterEither 都表示：「兩個任務，只要有一個任務完成，就執行任務三」 。

區別在于：

• 「runAfterEither」 ：不會把執行結果當做方法入參，且沒有返回值
• 「acceptEither」 : 會將已經執行完成的任務，作為方法入參，傳遞到指定方法中，且無返回值
• 「applyToEither」 ：會將已經執行完成的任務，作為方法入參，傳遞到指定方法中，且有返回值

示例

@Test
publicvoidtestCompletableEitherAsync(){
//創建線程池
ExecutorServiceexecutorService=Executors.newFixedThreadPool(10);
//開啟異步任務1
CompletableFuturetask=CompletableFuture.supplyAsync(()->{
System.out.println("異步任務1，當前線程是："+Thread.currentThread().getId());

intresult=1+1;
System.out.println("異步任務1結束");
returnresult;
},executorService);

//開啟異步任務2
CompletableFuturetask2=CompletableFuture.supplyAsync(()->{
System.out.println("異步任務2，當前線程是："+Thread.currentThread().getId());
intresult=1+2;
try{
Thread.sleep(3000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println("異步任務2結束");
returnresult;
},executorService);

//任務組合
task.acceptEitherAsync(task2,(res)->{
System.out.println("執行任務3，當前線程是："+Thread.currentThread().getId());
System.out.println("上一個任務的結果為："+res);
},executorService);
}

運行結果

//通過結果可以看出，異步任務2都沒有執行結束，任務3獲取的也是1的執行結果
異步任務1，當前線程是：17
異步任務1結束
異步任務2，當前線程是：18
執行任務3，當前線程是：19
上一個任務的結果為：2

注意

如果把上面的核心線程數改為1也就是

ExecutorServiceexecutorService=Executors.newFixedThreadPool(1);

運行結果就是下面的了，會發現根本沒有執行任務3，顯然是任務3直接被丟棄了。

異步任務1，當前線程是：17
異步任務1結束
異步任務2，當前線程是：17

3、多任務組合

• 「allOf」 ：等待所有任務完成
• 「anyOf」 ：只要有一個任務完成

示例

allOf：等待所有任務完成

@Test
publicvoidtestCompletableAallOf()throwsExecutionException,InterruptedException{
//創建線程池
ExecutorServiceexecutorService=Executors.newFixedThreadPool(10);
//開啟異步任務1
CompletableFuturetask=CompletableFuture.supplyAsync(()->{
System.out.println("異步任務1，當前線程是："+Thread.currentThread().getId());
intresult=1+1;
System.out.println("異步任務1結束");
returnresult;
},executorService);

//開啟異步任務2
CompletableFuturetask2=CompletableFuture.supplyAsync(()->{
System.out.println("異步任務2，當前線程是："+Thread.currentThread().getId());
intresult=1+2;
try{
Thread.sleep(3000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println("異步任務2結束");
returnresult;
},executorService);

//開啟異步任務3
CompletableFuturetask3=CompletableFuture.supplyAsync(()->{
System.out.println("異步任務3，當前線程是："+Thread.currentThread().getId());
intresult=1+3;
try{
Thread.sleep(4000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println("異步任務3結束");
returnresult;
},executorService);

//任務組合
CompletableFutureallOf=CompletableFuture.allOf(task,task2,task3);

//等待所有任務完成
allOf.get();
//獲取任務的返回結果
System.out.println("task結果為："+task.get());
System.out.println("task2結果為："+task2.get());
System.out.println("task3結果為："+task3.get());
}

anyOf: 只要有一個任務完成

@Test
publicvoidtestCompletableAnyOf()throwsExecutionException,InterruptedException{
//創建線程池
ExecutorServiceexecutorService=Executors.newFixedThreadPool(10);
//開啟異步任務1
CompletableFuturetask=CompletableFuture.supplyAsync(()->{
intresult=1+1;
returnresult;
},executorService);

//開啟異步任務2
CompletableFuturetask2=CompletableFuture.supplyAsync(()->{
intresult=1+2;
returnresult;
},executorService);

//開啟異步任務3
CompletableFuturetask3=CompletableFuture.supplyAsync(()->{
intresult=1+3;
returnresult;
},executorService);

//任務組合
CompletableFuture