国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

java8的CompletableFuture使用實例

kycool / 823人閱讀

摘要：這個方法返回與等待所有返回等待多個返回取多個當中最快的一個返回等待多個當中最快的一個返回二詳解終極指南并發編程中的風格

thenApply(等待并轉化future) 
    @Test
    public void testThen() throws ExecutionException, InterruptedException {
        CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {
            return "zero";
        }, executor);

        CompletableFuture f2 = f1.thenApply(new Function() {

            @Override
            public Integer apply(String t) {
                System.out.println(2);
                return Integer.valueOf(t.length());
            }
        });

        CompletableFuture f3 = f2.thenApply(r -> r * 2.0);
        System.out.println(f3.get());
    }
thenAccept與thenRun(監聽future完成) 
/**
     * future完成處理,可獲取結果
     */
    @Test
    public void testThenAccept(){
        CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {
            return "zero";
        }, executor);
        f1.thenAccept(e -> {
            System.out.println("get result:"+e);
        });
    }

    /**
     * future完成處理
     */
    @Test
    public void testThenRun(){
        CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {
            return "zero";
        }, executor);
        f1.thenRun(new Runnable() {
            @Override
            public void run() {
                System.out.println("finished");
            }
        });
    }
thenCompose(flatMap future) 
/**
     * compose相當于flatMap,避免CompletableFuture>這種
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Test
    public void testThenCompose() throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {
            return "zero";
        }, executor);
        CompletableFuture> f4 = f1.thenApply(CompletableFutureTest::calculate);
        System.out.println("f4.get:"+f4.get().get());

        CompletableFuture f5 = f1.thenCompose(CompletableFutureTest::calculate);
        System.out.println("f5.get:"+f5.get());

        System.out.println(f1.get());
    }

    public static CompletableFuture calculate(String input) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            System.out.println(input);
            return input + "---" + input.length();
        }, executor);
        return future;
    }
thenCombine與thenAcceptBoth

thenCombine(組合兩個future，有返回值)

/**
     * thenCombine用于組合兩個并發的任務,產生新的future有返回值
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Test
    public void testThenCombine() throws ExecutionException, InterruptedException {
        CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("f1 start to sleep at:"+System.currentTimeMillis());
                Thread.sleep(1000);
                System.out.println("f1 finish sleep at:"+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "zero";
        }, executor);
        CompletableFuture f2 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("f2 start to sleep at:"+System.currentTimeMillis());
                Thread.sleep(3000);
                System.out.println("f2 finish sleep at:"+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello";
        }, executor);

        CompletableFuture reslutFuture =
                f1.thenCombine(f2, new BiFunction() {

                    @Override
                    public String apply(String t, String u) {
                        System.out.println("f3 start to combine at:"+System.currentTimeMillis());
                        return t.concat(u);
                    }
                });

        System.out.println(reslutFuture.get());//zerohello
        System.out.println("finish combine at:"+System.currentTimeMillis());
    }

thenAcceptBoth(組合兩個future,沒有返回值)

/**
     * thenAcceptBoth用于組合兩個并發的任務,產生新的future沒有返回值
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Test
    public void testThenAcceptBoth() throws ExecutionException, InterruptedException {
        CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("f1 start to sleep at:"+System.currentTimeMillis());
                TimeUnit.SECONDS.sleep(1);
                System.out.println("f1 stop sleep at:"+System.currentTimeMillis());
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return "zero";
        }, executor);
        CompletableFuture f2 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("f2 start to sleep at:"+System.currentTimeMillis());
                TimeUnit.SECONDS.sleep(3);
                System.out.println("f2 stop sleep at:"+System.currentTimeMillis());
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return "hello";
        }, executor);

        CompletableFuture reslutFuture = f1.thenAcceptBoth(f2, new BiConsumer() {
            @Override
            public void accept(String t, String u) {
                System.out.println("f3 start to accept at:"+System.currentTimeMillis());
                System.out.println(t + " over");
                System.out.println(u + " over");
            }
        });

        System.out.println(reslutFuture.get());
        System.out.println("finish accept at:"+System.currentTimeMillis());

    }
applyToEither與acceptEither

applyToEither(取2個future中最先返回的,有返回值)

/**
     * 當任意一個CompletionStage 完成的時候，fn 會被執行,它的返回值會當做新的CompletableFuture的計算結果
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Test
    public void testApplyToEither() throws ExecutionException, InterruptedException {
        CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("f1 start to sleep at:"+System.currentTimeMillis());
                TimeUnit.SECONDS.sleep(5);
                System.out.println("f1 stop sleep at:"+System.currentTimeMillis());
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return "fromF1";
        }, executor);
        CompletableFuture f2 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("f2 start to sleep at:"+System.currentTimeMillis());
                TimeUnit.SECONDS.sleep(2);
                System.out.println("f2 stop sleep at:"+System.currentTimeMillis());
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return "fromF2";
        }, executor);

        CompletableFuture reslutFuture = f1.applyToEither(f2,i -> i.toString());
        System.out.println(reslutFuture.get()); //should not be null , wait for complete
    }

acceptEither(取2個future中最先返回的,無返回值)

/**
     * 取其中返回最快的一個
     * 當任意一個CompletionStage 完成的時候，action 這個消費者就會被執行。這個方法返回 CompletableFuture
     */
    @Test
    public void testAcceptEither() throws ExecutionException, InterruptedException {
        CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("f1 start to sleep at:"+System.currentTimeMillis());
                TimeUnit.SECONDS.sleep(3);
                System.out.println("f1 stop sleep at:"+System.currentTimeMillis());
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return "zero";
        }, executor);
        CompletableFuture f2 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("f2 start to sleep at:"+System.currentTimeMillis());
                TimeUnit.SECONDS.sleep(5);
                System.out.println("f2 stop sleep at:"+System.currentTimeMillis());
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return "hello";
        }, executor);

        CompletableFuture reslutFuture = f1.acceptEither(f2,r -> {
            System.out.println("quicker result:"+r);
        });
        reslutFuture.get(); //should be null , wait for complete

    }
allOf與anyOf

allOf(等待所有future返回)

    /**
     * 等待多個future返回
     */
    @Test
    public void testAllOf() throws InterruptedException {
        List> futures = IntStream.range(1,10)
                .mapToObj(i ->
                        longCost(i)).collect(Collectors.toList());
        final CompletableFuture allCompleted = CompletableFuture.allOf(futures.toArray(new CompletableFuture[]{}));
        allCompleted.thenRun(() -> {
            futures.stream().forEach(future -> {
                try {
                    System.out.println("get future at:"+System.currentTimeMillis()+", result:"+future.get());
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            });

        });
        Thread.sleep(100000); //wait
    }

anyOf(取多個future當中最快的一個返回)

/**
     * 等待多個future當中最快的一個返回
     * @throws InterruptedException
     */
    @Test
    public void testAnyOf() throws InterruptedException {
        List> futures = IntStream.range(1,10)
                .mapToObj(i ->
                        longCost(i)).collect(Collectors.toList());
        final CompletableFuture firstCompleted = CompletableFuture.anyOf(futures.toArray(new CompletableFuture[]{}));
        firstCompleted.thenAccept((Object result) -> {
            System.out.println("get at:"+System.currentTimeMillis()+",first result:"+result);
        });
    }

    private CompletableFuture longCost(long i){
        return CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("f"+i+" start to sleep at:"+System.currentTimeMillis());
                Thread.sleep(3000);
                System.out.println("f"+i+" stop sleep at:"+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return String.valueOf(i);
        },executor);
    }
doc


CompletableFuture（二）


Java CompletableFuture 詳解


Java 8：CompletableFuture終極指南


Java 8: Definitive guide to CompletableFuture


并發編程 | JDK 1.8中的CompletableFuture | FRP風格

           
               
                                           
                       
                 
            
                     
             
               

                   
 文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

                 
                   
轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/66708.html

               

                      
               
              
              

                
相關文章

                
    
                             
                                                                    
  • 
                                                
    
                          
    Java8的CompletableFuture進階之道
    
                                                     
    摘要：方法接收的是的實例，但是它沒有返回值方法是函數式接口，無參數，會返回一個結果這兩個方法是的升級，表示讓任務在指定的線程池中執行，不指定的話，通常任務是在線程池中執行的。該的接口是在線程使用舊的接口，它不允許返回值。

簡介
作為Java 8 Concurrency API改進而引入，本文是CompletableFuture類的功能和用例的介紹。同時在Java 9 也有對Completab...
    
                                                   
                          
    
                                
    
                                    SunZhaopeng
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                                                       
  • 
                                                
    
                          
    《Java8實戰》-第十一章筆記（CompletableFuture：組合式異步編程）
    
                                                     
    摘要：組合式異步編程最近這些年，兩種趨勢不斷地推動我們反思我們設計軟件的方式。第章中介紹的分支合并框架以及并行流是實現并行處理的寶貴工具它們將一個操作切分為多個子操作，在多個不同的核甚至是機器上并行地執行這些子操作。

CompletableFuture：組合式異步編程
最近這些年，兩種趨勢不斷地推動我們反思我們設計軟件的方式。第一種趨勢和應用運行的硬件平臺相關，第二種趨勢與應用程序的架構相關...
    
                                                   
                          
    
                                
    
                                    hlcfan
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    強大的CompletableFuture
    
                                                     
    摘要：首先想到的是開啟一個新的線程去做某項工作。再進一步，為了讓新線程可以返回一個值，告訴主線程事情做完了，于是乎粉墨登場。然而提供的方式是主線程主動問詢新線程，要是有個回調函數就爽了。極大的提高效率。

showImg(https://segmentfault.com/img/bVbvgBJ?w=1920&h=1200);
引子
為了讓程序更加高效，讓CPU最大效率的工作，我們會采用異步編程...
    
                                                   
                          
    
                                
    
                                    skinner
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    ForkJoin框架之CompletableFuture
    
                                                     
    摘要：內部類，用于對和異常進行包裝，從而保證對進行只有一次成功。是取消異常，轉換后拋出。判斷是否使用的線程池，在中持有該線程池的引用。

前言
近期作者對響應式編程越發感興趣，在內部分享JAVA9-12新特性過程中，有兩處特性讓作者深感興趣：1.JAVA9中的JEP266對并發編程工具的更新，包含發布訂閱框架Flow和CompletableFuture加強，其中發布訂閱框架以java.base...
    
                                                   
                          
    
                                
    
                                    lindroid
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    用CompletableFuture實現異步任務
    
                                                     
    摘要：項目需求項目中需要優化一個接口，這個接口需要拉取個第三方接口，需求延遲時間小于技術選型是提出的一個支持非阻塞的多功能的，同樣也是實現了接口，是添加的類，用來描述一個異步計算的結果。對進一步完善，擴展了諸多功能形成了。

項目需求：
項目中需要優化一個接口，這個接口需要拉取23個第三方接口，需求延遲時間小于200ms;
技術選型：
CompletableFuture是JDK8提出的一個支持...
    
                                                   
                          
    
                                
    
                                    劉東
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                           
                

              

              
               

                  
                  
發表評論

                   
               

              

                

                  
0條評論
   
                
 
                      

              

           
           

              
 
                

                    
                    
kycool

                    
男|高級講師

                    
                    

                          
TA的文章

                          閱讀更多
                    

                      
                


                   
              
  

                  
最新活動
 
           
                             
              





                                
              

           

        
       
    
    
     

      
    

    
    

    
       
       

         
閱讀需要支付1元查看
  
         
     
       

      
  
    
    








        

            

              
              
            

             
        

    







<