精品国产一区二区三区不卡免费_黄片在线免费观看一区二区三区_国产午夜福利精品集在线观看

1 CompletableFuture的靜態方法使用

CompleteableFuture的靜態方法有如下

之前的文章里面已經講過suuplyAsync，以及runAsync。我們就直接看其他方法

delayedExcutor

delayedExcutor其作用是構建一個延遲執行任務的Excutor，默認使用ForkJoinPool. 也可以使用自定義的Excutor。

一個延遲5秒執行任務的Excutor，默認使用使用ForkJoinPool.commonPool()。
Executor executor = CompletableFuture.delayedExecutor(5l, TimeUnit.SECONDS);

allof和anyof

allof和anyof 為等待多個CompletableFuture完成之后返回一個CompletableFuture。

allof返回無result，
anyof返回為最先完成的CompletableFuture。

可以看如下示例。

CompletableFuture< String > supplyAsync1 = CompletableFuture.supplyAsync(()- >{
    try {Thread.sleep(4 * 1000);} catch (InterruptedException e) {e.printStackTrace();}
    return "supplyAsync1";
});
CompletableFuture< String > supplyAsync2 = CompletableFuture.supplyAsync(() - > {
    try {Thread.sleep(2 * 1000);} catch (InterruptedException e) {e.printStackTrace();}
    return "supplyAsync2";
});
CompletableFuture.anyOf(supplyAsync1,supplyAsync2).thenAccept((str)- >{
    System.out.println(LocalDateTime.now() + " anyOf complete : " + str);
});
CompletableFuture.allOf(supplyAsync1,supplyAsync2).thenAccept((str)- >{
    System.out.println(LocalDateTime.now() + " allOf complete "+ str );
});

執行結果如下:

start second: 2021-10-24T12:39:40.562001600
2021-10-24T12:39:42.611118800 anyOf complete : supplyAsync2
2021-10-24T12:39:44.611233200 allOf complete null

failedStage和failedFuture是返回一個已知異常的CompletableFuture。這個下面和其他異常一起舉例。

2 CompletableFuture的其余方法使用

CompletableFuture中方法可以大致分為run，apply，accept幾個類別。其對應的參數分別為Runnable，Function，Consummer等幾個函數式表達式。

run代表當前CompletableFuture完成后執行的一些列操作，無輸入參數，無返回結果，所以只是Runnable為參數。()-> { option }
apply代表以當前CompletableFuture完成后的結果為參數進行的操作，并且會返回一個新的CompletableFuture，所以以Function為參數。(s)-> {return s;}
accept代表以當前CompletableFuture完成后的結果為參數，執行的操作，無返回結果，直接消費。以Consumer為參數，(s)-> { option }。

2.1 Run方法

Run方法相關參數為Runnable，為直接執行的操作。

thenRun 完成之后直接執行。

thenRunAsync 使用線程池異步執行,線程池默認為ForkJoinPool.commonPool

runAfterBoth/ runAfterEither 兩個CompletableFuture同時完成或者某一個完成就執行的操作。

runAfterBothAsync/runAfterEitherAsync 同理為使用線程池異步執行的操作。

public class CompletableFutureThenRun {
    public static void main(String[] args) {
        System.out.println(" CompletableFutureThenRun main start : " + LocalDateTime.now());
        CompletableFuture< String > cf1 = CompletableFuture.supplyAsync(() - > {
            System.out.println(" CompletableFutureThenRun  cf1: " + LocalDateTime.now());
            try {
                Thread.sleep(5 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "supplyAsync";
        });

        CompletableFuture< Void > cf2 = CompletableFuture.runAsync(() - > {
            System.out.println(" CompletableFutureThenRun  cf2: " + LocalDateTime.now());
            try {
                Thread.sleep(2 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        cf1.runAfterBoth(cf2,()- > {
            System.out.println(Thread.currentThread().getName()+" CompletableFutureThenRun runAfterBoth: " + LocalDateTime.now());
        });
        cf1.runAfterBothAsync(cf2,()- > {
            System.out.println( Thread.currentThread().getName()+" CompletableFutureThenRun runAfterBothAsync: " + LocalDateTime.now());
        });
        cf1.runAfterEither(cf2,()- > {
            System.out.println( Thread.currentThread().getName()+" CompletableFutureThenRun runAfterEither: " + LocalDateTime.now());
        });
        cf1.runAfterEitherAsync(cf2,()- > {
            System.out.println( Thread.currentThread().getName()+" CompletableFutureThenRun runAfterEitherAsync: " + LocalDateTime.now());
        });
        cf1.thenRunAsync(()- > {
            System.out.println(Thread.currentThread().getName()+" CompletableFutureThenRun thenRunAsync: " + LocalDateTime.now());
        });
        cf1.thenRun(()- > {
            System.out.println(Thread.currentThread().getName()+" CompletableFutureThenRun thenRun: " + LocalDateTime.now());
        });
        System.out.println(Thread.currentThread().getName() + " CompletableFutureThenRun  last: " + LocalDateTime.now());

        try {
            Thread.sleep(10*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

上述執行結果：

CompletableFutureThenRun main start : 2021-10-25T01:48:52.416000900
 CompletableFutureThenRun  cf1: 2021-10-25T01:48:52.492008500
 CompletableFutureThenRun  cf2: 2021-10-25T01:48:52.493008600
main CompletableFutureThenRun  last: 2021-10-25T01:48:52.495008800
ForkJoinPool.commonPool-worker-7 CompletableFutureThenRun runAfterEitherAsync: 2021-10-25T01:48:54.495208800
ForkJoinPool.commonPool-worker-3 CompletableFutureThenRun runAfterEither: 2021-10-25T01:48:54.495208800
ForkJoinPool.commonPool-worker-5 CompletableFutureThenRun thenRun: 2021-10-25T01:48:57.493508600
ForkJoinPool.commonPool-worker-3 CompletableFutureThenRun thenRunAsync: 2021-10-25T01:48:57.494508700
ForkJoinPool.commonPool-worker-3 CompletableFutureThenRun runAfterBoth: 2021-10-25T01:48:57.494508700
ForkJoinPool.commonPool-worker-3 CompletableFutureThenRun runAfterBothAsync: 2021-10-25T01:48:57.495508800

apply 與accept相關的方法類似，此處不一一舉例了。

下面我們根據一些情景舉例來說明方法如何使用：

2.2 多個 CompletableFuture組合在一起執行

情景一 ：先去取快遞，然后再去買菜，然后回家做飯。

CompletableFuture< String > cf = CompletableFuture.supplyAsync(()- >{
    System.out.println(LocalDateTime.now() + " 正在取快遞！ ");
    try {Thread.sleep(2 * 1000);} catch (InterruptedException e) {e.printStackTrace();}
    return "快遞1";
}).thenApply((str) - > {
    System.out.println(LocalDateTime.now() + " 拿到了： "+str);
    System.out.println(LocalDateTime.now() + " 買菜中。。。 ");
    try {Thread.sleep(2 * 1000);} catch (InterruptedException e) {e.printStackTrace();}
    return str + " 和 蔬菜";
}).thenApply((str2)- >{
    System.out.println(LocalDateTime.now() + " 現在有了： ["+str2+"]");
    try {Thread.sleep(2 * 1000);} catch (InterruptedException e) {e.printStackTrace();}
    return "帶著 [" + str2 + " ]回家做飯" ;
});
System.out.println( LocalDateTime.now() + " 美好的一天： "+ cf.join());

下面看一下上面的執行結果，

2021-10-25T01:10:16.831465600 正在取快遞！ 
2021-10-25T01:10:18.861668600 拿到了： 快遞1
2021-10-25T01:10:18.911673600 買菜中。。。 
2021-10-25T01:10:20.911873600 現在有了： [快遞1 和 蔬菜]
2021-10-25T01:10:16.831465600 美好的一天： 帶著 [快遞1 和 蔬菜 ]回家做飯

可以看到最后一行輸出的時間比較早，這是因為join會阻塞線程，直到此CompletableFuture執行完并獲取到值。

情景二 ：和女朋友一起出門，我去取快遞，女朋友去買菜，然后一起回家做飯。

CompletableFuture< String > cf1 = CompletableFuture.supplyAsync(()- >{
    System.out.println(LocalDateTime.now() + " 正在取快遞！ ");
    try {Thread.sleep(2 * 1000);} catch (InterruptedException e) {e.printStackTrace();}
    return "快遞";
});
CompletableFuture< String > cf2 = CompletableFuture.supplyAsync(()- >{
    System.out.println(LocalDateTime.now() + " 女朋友正在買菜！ ");
    try {Thread.sleep(4 * 1000);} catch (InterruptedException e) {e.printStackTrace();}
    return "蔬菜";
});

cf1.thenAcceptBoth(cf2,(str1 ,str2 )- >{
    System.out.println(LocalDateTime.now() +  " ["+ str1 + "]["+str2+"] 帶回來了，開始做飯 ");
}).join();

此處使用 thenAcceptBoth 需要在兩個CompletableFuture都完成的情況下，才能執行，所以最后使用join（）使其阻塞到可以執行當前的操作。

情景三 ：和女朋友一起出門，我去取快遞，女朋友去買菜，誰先弄完誰就先回去。

cf1.acceptEither(cf2,(str1 )- >{
    System.out.println(LocalDateTime.now() +  " ["+ str1 +"] 帶回來了，先回家吧！ ");
}).join();

我先拿到了快遞，就快快的回家了，然后就挨了一頓毒打。

2.3 在兩個CompletableFuture運行后再次計算

晚飯過后和女朋友討論做什么事情，然而發生了分歧：

CompletableFuture< List< String >> cf1 = CompletableFuture.supplyAsync(()- >{
    List< String > strings = Arrays.asList("看電影", "打撲克");
    System.out.println(LocalDateTime.now() + " 晚飯后女朋友說，想要： " + strings);
    try {Thread.sleep(2 * 1000);} catch (InterruptedException e) {e.printStackTrace();}
    return strings;
});
CompletableFuture< List< String >> cf2 = CompletableFuture.supplyAsync(()- >{
    List< String > strings = Arrays.asList("看電影", "打游戲");
    System.out.println(LocalDateTime.now() + " 晚飯后，我想： " + strings);
    try {Thread.sleep(4 * 1000);} catch (InterruptedException e) {e.printStackTrace();}
    return strings;
});

cf1.thenCombine(cf2,(list1,list2) - > {
        System.out.println("遭受了一頓毒打之后。。。?。?！");
    List< String > collect = list1.stream().filter(str - > list2.contains(str)).collect(Collectors.toList());
    System.out.println(LocalDateTime.now() + " 綜合兩個人的想法，最終決定： " + collect);
    return collect;
}).join();

女朋友想看電影，或者打撲克，

但是我想打游戲。最后遭受一頓毒打之后，還是說出了或者看電影。

最終選擇了看電影。

4 CompletableFuture的異常處理

CompletableFuture和異常相關的方法有如下

4.1 whenComplete/whenCompleteAsync

CompletableFuture< T > whenComplete(
    BiConsumer< ? super T, ? super Throwable > action)

whenCompletable使用有BiConsumer里面會有兩個參數，下邊是一個示例。參數需要兩個分別為str，exception，如果有異常exception有值，str為null。如果stringCompletableFuture正常完成，則exception為null。但是不管是否有異常，表達式里面的方法均會執行。

有點類似try finally{}，有沒有異常均可執行。

CompletableFuture< String > whenCompleteCF = stringCompletableFuture.whenComplete((str, exception) - > {
            if(exception != null){
                System.out.println("whenComplete ： " + exception);
                exception.printStackTrace();
            }
            System.out.println("whenComplete execute whither error throw ");
});

4.2 exceptionally

exceptionally方法中為一個Function參數，需要一個輸入值，為當前CompletableFuture拋出的異常。

其返回值有兩個結果：

如果當前CompletableFuture無異常完成，則返回與原CompletableFuture的result相同的CompletableFuture，注意知識result相同，并不是同一個類。
如果當前CompletableFuture有異常拋出，那么返回新的CompletableFuture以及新處理后的result。

CompletableFuture< String > stringCompletableFuture = CompletableFuture.supplyAsync(() - > {
            throw new RuntimeException(" CompletableFuture throw one exception");
//            return "cc";
        });

        CompletableFuture< String > exceptionally = stringCompletableFuture.exceptionally((exception) - > {
            System.out.println("exceptionally only execute  when error throw ");
            return "exception";
        });
         System.out.println("exceptionally  ： " + exceptionally.join());

上述示例無異常拋出時結果如下：

exceptionally  ：cc

有異常拋出時結果如下：

exceptionally only execute  when error throw 
exceptionally  ：exception

4.3 handle/handleAsync

public < U > CompletableFuture< U > handle(
    BiFunction< ? super T, Throwable, ? extends U > fn)

handle 和 whenComplete 比較類似，無論有沒有異常，里面的方法均會執行到。

但是有有一些區別，handle參數為BiFunction，有返回值，whenComplet的參數為BiComsumer 無返回值。

下面的實例中，如果有異常則參數中的str為null，如果沒有異常exception為null。

CompletableFuture< String > handle = stringCompletableFuture.handle((str, exception) - > {
    System.out.println("handle ： " + str);
    if(exception != null ){
        System.out.println("stringCompletableFuture1 have exception :" );
        exception.printStackTrace();
    }
    return "handle complete ";
});

有異常的執行結果：

stringCompletableFuture1 have exception :
handle.join(); ：handle complete

無異常的執行結果

handle ：cc
handle.join(); ：handle complete

4.4 failedStage/failedFuture

failedStage和failedFuture均為靜態方法，會返回一個已完成的給定異常的CompletableFuture。

failedStage返回的是CompletionStage，failedFuture返回為CompletableFuture對象

CompletionStage< Object > test_exception = CompletableFuture.failedStage(new RuntimeException("test exception"));
CompletableFuture< Object > test_exception1 = CompletableFuture.failedFuture(new RuntimeException("test exception"));

最后給一個可以直接食用的示例，可以根據不同的需求進行改良哦！

public static Map< String, List< Integer >> testMap = new ConcurrentHashMap<  >();

static {
    testMap.put("A", Arrays.asList(1,2,3,4,5));
    testMap.put("B", Arrays.asList(6,7,8,9,10));
    testMap.put("C", Arrays.asList(11,12,13,14,15));
    testMap.put("D", Arrays.asList(21,22,23,24,25));
    testMap.put("E", Arrays.asList(31,32,33,34,35));
}

public static void main(String[] args) {
    System.out.println(" CompletableFutureDemo5 main start : " + LocalDateTime.now());
    List< String > strings = Arrays.asList("A", "B", "C", "D", "E");

    ExecutorService testPool = new ForkJoinPool(4);
    List< CompletableFuture< List< Integer >> > collect = strings.stream().map(
            key - > CompletableFuture.supplyAsync(() - > {
                return obtainTheList(key);
            },testPool).exceptionally((exc)- >{
                System.out.println(" hit  the exception " );
                throw new RuntimeException(exc);
            })
    ).collect(Collectors.toList());

    System.out.println(" CompletableFutureDemo5 supplyAsync end : " + LocalDateTime.now());
    try {
        List< List< Integer >> integerCollect = collect.stream().map(CompletableFuture::join).collect(Collectors.toList());
    }catch (Exception e){
        System.out.println(" catch  the exception " + e.getMessage());
        e.printStackTrace();
    }
    System.out.println(" CompletableFutureDemo5 main end : " + LocalDateTime.now());
    try {
        Thread.sleep(5*1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

}

private static List< Integer > obtainTheList(String key) {
    List< Integer > integers = testMap.get(key);
    if( key.equals("C") ){
        throw new RuntimeException("exception test !");
    }
    try {
        Thread.sleep(2*1000);
        System.out.println(" obtainTheList thread name : " + Thread.currentThread().getName() +" : "+ LocalDateTime.now());
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return integers==null? new ArrayList() :integers;
}

總結

本片用了一些示例來講解CompletableFuture，我們可以在開發中的一些場景中使用起來了。特別是異步多線程去拿一些數據的時候，非常好用哦。

聲明：本文內容及配圖由入駐作者撰寫或者入駐合作網站授權轉載。文章觀點僅代表作者本人，不代表電子發燒友網立場。文章及其配圖僅供工程師學習之用，如有內容侵權或者其他違規問題，請聯系本站處理。舉報投訴

參數

參數

+關注

關注
11

文章
1785

瀏覽量
32086
函數

函數

+關注

關注
3

文章
4305

瀏覽量
62430

降低靜態電流的方法

用電池電源進行設計時需要考慮的問題用于電池電源控制和保護的低靜態電流解決方案降低靜態電流的方法

發表于 03-03 06:01

傳統靜態配置方法與動態配置方法的區別在哪？

傳統靜態配置方法有什么缺點？MAC地址和IP地址的動態配置方法是什么？傳統靜態配置方法與動態配置方法

發表于 05-27 06:51

python靜態方法與類方法

python靜態方法與類方法1. 寫法上的差異類的方法可以分為：靜態方法：有 staticmet

發表于 03-07 16:56

ASIC靜態驗證方法

介紹了基于深亞微米 CMOS 工藝A S IC 電路設計流程中的靜態驗證方法。將這種驗證方法與以往的動態驗證方法進行了比較, 結果表明, 前者比后者更加高效和準確。由此可以說明,

發表于 06-21 15:05 ?0次下載

基于突變理論的風電場靜態電壓穩定分析方法

基于突變理論的風電場靜態電壓穩定分析方法_葛江北

發表于 01-05 15:33 ?0次下載

基于內容的靜態語義概念視頻檢索方法研究_張聰

基于內容的靜態語義概念視頻檢索方法研究_張聰

發表于 03-16 10:34 ?1次下載

基于靜態分析的Android GUI遍歷方法

針對傳統軟件安全測試方法（例如：符號執行、模糊測試、污點分析等）無法獲得較高的Android程序圖形用戶界面（ GUI）覆蓋率的問題，提出動態和靜態相結合的Android程序測試方法。該方法

發表于 12-11 11:32 ?0次下載

python靜態方法與類方法

python靜態方法與類方法 1. 寫法上的差異類的方法可以分為：靜態方法：有 static

發表于 03-07 16:56 ?1554次閱讀

步進電機的特性測量方法(靜態特性)

為了評估步進電機的特性必須要有必要的測量方法。本章針對步進電機的基本特性①靜態特性:靜態轉矩特性，步進角度精度;②動態特性:速度-轉矩特性;③暫態特件；介紹各種測量方法。并且進一步

發表于 03-23 10:00 ?1次下載

數碼管的靜態、動態顯示原理及編程方法(1)

“掌握數碼管的靜態、動態顯示原理及編程方法。--不是綜合案例”

發表于 06-28 11:40 ?2560次閱讀

數碼管的靜態、動態顯示原理及編程方法(2)

“掌握數碼管的靜態、動態顯示原理及編程方法。--綜合案例”

發表于 06-28 11:41 ?1509次閱讀

Python中普通方法、靜態方法、類方法的區別

：靜態方法，和普通的函數沒有什么區別下面將聊聊實際項目中幾種應用場景 1、要調用一個靜態方法，一般使用形式是：「類名.方法

發表于 11-02 11:03 ?781次閱讀

常用的變頻器檢測方法靜態測試和動態測試

常用的變頻器檢測方法靜態測試和動態測試? 變頻器是一種電力調節裝置，可以實現對電動機的調速和節能。在使用變頻器時，經常需要對其進行檢測，以確保其正常工作。常用的變頻器檢測方法主要包括靜態

發表于 02-01 15:47 ?4354次閱讀

Java CompletableFuture 異步超時實現探索

簡介 JDK 8 中 CompletableFuture 沒有超時中斷任務的能力?，F有做法強依賴任務自身的超時實現。本文提出一種異步超時實現方案，解決上述問題。前言 JDK 8 是一次重大的版本

發表于 07-25 14:06 ?310次閱讀

精品国产人成在线_亚洲高清无码在线观看_国产在线视频国产永久2021_国产AV综合第一页一个的一区免费影院黑人_最近中文字幕MV高清在线视频

搜索歷史

CompletableFuture的靜態方法使用

1 CompletableFuture的靜態方法使用

delayedExcutor

allof和anyof

2 CompletableFuture的其余方法使用

2.1 Run方法

2.2 多個 CompletableFuture組合在一起執行

2.3 在兩個CompletableFuture運行后再次計算

4 CompletableFuture的異常處理

4.1 whenComplete/whenCompleteAsync

4.2 exceptionally

4.3 handle/handleAsync

4.4 failedStage/failedFuture

總結

評論

請問Python中的類方法、實例方法和靜態方法是什么？

降低靜態電流的方法

傳統靜態配置方法與動態配置方法的區別在哪？

python靜態方法與類方法

ASIC靜態驗證方法

基于突變理論的風電場靜態電壓穩定分析方法

基于內容的靜態語義概念視頻檢索方法研究_張聰

基于靜態分析的Android GUI遍歷方法

python靜態方法與類方法

步進電機的特性測量方法(靜態特性)

數碼管的靜態、動態顯示原理及編程方法(1)

數碼管的靜態、動態顯示原理及編程方法(2)

Python中普通方法、靜態方法、類方法的區別

常用的變頻器檢測方法靜態測試和動態測試

Java CompletableFuture 異步超時實現探索