CompletableFuture异步编程

package com.gupaoedu.completablefuture;

//折扣类型，包含枚举类型 和应用报价的方法。
public class Discount {
    static double rete = 0.5;

    /**
     * 模拟查询汇率
     * @return
     */
    public static double getRate() {
        return rete;
    }

    public enum Code{
        NONE(0),
        SILVER(5),
        GOLD(10),
        PLATINUM(15),
        DIAMOND(20);

        private final int percentage;
        Code(int percentage){
            this.percentage = percentage;
        }
    }

    public static String applyDiscount(Quote quote){
        return quote.getShopName() + " price is " + Discount.apply(quote.getPrice(),quote.getCode());
    }


    public static double apply(double price, Code code){
        delay();
        return  price * (100 - code.percentage) /100 ;
    }

    public static void delay(){
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 1 package com.gupaoedu.completablefuture;
  2 
  3 import org.junit.Test;
  4 import java.util.Arrays;
  5 import java.util.List;
  6 import java.util.concurrent.*;
  7 import static java.util.stream.Collectors.toList;
  8 
  9 public class Client {
 10 
 11     @Test
 12     public void test0() throws Exception {
 13         long start = System.currentTimeMillis();
 14         ExecutorService executorService = Executors.newCachedThreadPool();
 15         Future<Double> future = executorService.submit(() -> {
 16             Thread.sleep(1000L);
 17             return Math.random();
 18         });
 19         Thread.sleep(1000L);
 20         try {
 21             /** 获取线程执行的结果，传递的是等待线程的时间，单位是1秒 */
 22             future.get(1, TimeUnit.SECONDS);
 23         } catch (ExecutionException e) {
 24             e.printStackTrace();
 25         } catch (TimeoutException e) {
 26             e.printStackTrace();
 27         }
 28         System.out.println("共耗时" + (System.currentTimeMillis() - start) + "ms");// 1014ms
 29     }
 30 
 31     @Test
 32     public void main() {
 33         Shop shop = new Shop("BestShop");
 34         long start = System.currentTimeMillis();
 35         Future<Double> future = shop.getPriceAsync("My Favorite");
 36         long invocationTime = System.currentTimeMillis() - start;
 37         System.out.println("调用接口时间：" + invocationTime + "毫秒");
 38 
 39         doSomethingElse();
 40 
 41         try {
 42             double price = future.get();
 43         } catch (InterruptedException e) {
 44             e.printStackTrace();
 45         } catch (ExecutionException e) {
 46             e.printStackTrace();
 47         }
 48 
 49         long retrievalTime = System.currentTimeMillis() - start;
 50         System.out.println("返回价格消耗时间：" + retrievalTime + "毫秒");
 51 
 52     }
 53 
 54     public static void doSomethingElse() {
 55         System.out.println("做其他的事情。。。");
 56     }
 57 
 58     @Test
 59     public void test1() {
 60         long start = System.currentTimeMillis();
 61         System.out.println(findPrice("java8实战"));
 62         long duration = System.currentTimeMillis() - start;
 63         System.out.println("总消耗时间：" + duration + "毫秒");
 64     }
 65 
 66 
 67     public static List<String> findPrice(String product) {
 68         List<Shop> shops = Arrays.asList(new Shop("sunjin.org"),
 69                 new Shop("加瓦匠"),
 70                 new Shop("京东商城"),
 71                 new Shop("天猫商城"));
 72         return shops.parallelStream()
 73                 .map(shop -> String.format("%s 的价格是 %.2f", shop.getName(), shop.getPrice(product)))
 74                 .collect(toList());
 75     }
 76 
 77     @Test
 78     public void test2() {
 79         long start = System.currentTimeMillis();
 80         System.out.println(findPrice2("java8实战"));
 81         long duration = System.currentTimeMillis() - start;
 82         System.out.println("总消耗时间：" + duration + "毫秒");
 83     }
 84     public static List<String> findPrice2(String product){
 85         List<Shop> shops = Arrays.asList(new Shop("sunjin.org"),
 86                 new Shop("加瓦匠"),
 87                 new Shop("京东商城"),
 88                 new Shop("天猫商城"));
 89         List<CompletableFuture<String>> priceFuture = shops.stream()
 90                 .map(shop -> CompletableFuture.supplyAsync( // 使用异步的方式计算每种商品的价格
 91                         () -> shop.getName() + " 的价格是 " + shop.getPrice(product)))
 92                 .collect(toList());
 93         return priceFuture.stream()
 94                 .map(CompletableFuture::join) //join 操作等待所有异步操作的结果
 95                 .collect(toList());
 96     }
 97 
 98     @Test
 99     public void test3() {
100         long start = System.currentTimeMillis();
101         System.out.println(findPrice3("java8实战"));
102         long duration = System.currentTimeMillis() - start;
103         System.out.println("总消耗时间：" + duration + "毫秒");
104     }
105 
106     public static List<String> findPrice3(String product){
107         List<Shop> shops = Arrays.asList(new Shop("sunjin.org"),
108                 new Shop("加瓦匠"),
109                 new Shop("京东商城"),
110                 new Shop("天猫商城"));
111         return shops.stream()
112                 .map(shop -> shop.getPrice2(product)) //获取原始报价
113                 .map(Quote::parse) //解析报价字符串
114                 .map(Discount::applyDiscount) //调用折扣服务应用报价折扣
115                 .collect(toList());
116     }
117 
118     @Test
119     public void test4() {
120         long start = System.currentTimeMillis();
121         System.out.println(findPrice4("java8实战"));
122         long duration = System.currentTimeMillis() - start;
123         System.out.println("总消耗时间：" + duration + "毫秒");
124     }
125 
126     private static Executor executor = Executors.newCachedThreadPool();
127     public static List<String> findPrice4(String product){
128         List<Shop> shops = Arrays.asList(new Shop("sunjin.org"),
129                 new Shop("加瓦匠"),
130                 new Shop("京东商城"),
131                 new Shop("天猫商城"));
132         List<CompletableFuture<String>> priceFuture = shops.stream()
133                 .map(shop -> CompletableFuture.supplyAsync( // 异步获取价格
134                         () -> shop.getPrice2(product), executor))
135                 .map(future -> future.thenApply(Quote::parse)) // 获取到价格后对价格解析
136                 .map(future -> future.thenCompose(quote -> CompletableFuture.supplyAsync( // 另一个异步任务构造异步应用报价
137                         () -> Discount.applyDiscount(quote), executor)))
138                 .collect(toList());
139         return priceFuture.stream()
140                 .map(CompletableFuture::join) //join 操作和get操作有相同的含义，等待所有异步操作的结果。
141                 .collect(toList());
142     }
143 
144 
145     @Test
146     public void test5() {
147         long start = System.currentTimeMillis();
148         System.out.println(findPrice5("java8实战"));
149         long duration = System.currentTimeMillis() - start;
150         System.out.println("总消耗时间：" + duration + "毫秒");
151     }
152 
153     public static List<Double> findPrice5(String product){
154         List<Shop> shops = Arrays.asList(new Shop("sunjin.org"),
155                 new Shop("加瓦匠"),
156                 new Shop("京东商城"),
157                 new Shop("天猫商城"));
158         List<CompletableFuture<Double>> priceFuture = shops.parallelStream()
159                 .map(shop -> CompletableFuture.supplyAsync( // 异步获取价格
160                         () -> shop.getPrice(product), executor))
161                 .map(future -> future.thenCombine(CompletableFuture.supplyAsync( // 异步获取折扣率
162                         () -> Discount.getRate(), executor)
163                         , (price, rate) -> price * rate)) // 将两个异步任务的结果合并
164                 .collect(toList());
165         return priceFuture.parallelStream()
166                 .map(CompletableFuture::join) //join 操作和get操作有相同的含义，等待所有异步操作的结果。
167                 .collect(toList());
168     }
169 
170 }

package com.gupaoedu.completablefuture;

public class Quote {
    private final String shopName;
    private final double price;
    private final Discount.Code code;

    public Quote(String shopName, double price, Discount.Code code) {
        this.shopName = shopName;
        this.price = price;
        this.code = code;
    }

    public String getShopName() {
        return shopName;
    }

    public double getPrice() {
        return price;
    }

    public Discount.Code getCode() {
        return code;
    }

    public static Quote parse(String s){
        String[] arr = s.split(":");
        return new Quote(arr[0], Double.valueOf(arr[1]), Discount.Code.valueOf(arr[2]));
    }
}

package com.gupaoedu.completablefuture;

import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;

public class Shop {
    private String name;
    private Random random = new Random();

    public Shop(String name) {
        this.name = name;
    }

    //直接获取价格
    public double getPrice(String product){
        return calculatePrice(product);
    }
    //模拟延迟
    public static void delay(){
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //模拟获取价格的服务
    private double calculatePrice(String product){
        delay();
        return random.nextDouble() * product.charAt(0) + product.charAt(1);
    }

    //异步获取价格
    public Future<Double> getPriceAsync(String product){
        CompletableFuture<Double> future = new CompletableFuture<>();
        new Thread(() -> {
            double price = calculatePrice(product);
            future.complete(price);
        }).start();
        return future;
    }

    public String getName() {
        return name;
    }

    //    获取价格字符串
    public String getPrice2(String product){
        double price = calculatePrice(product);
        Discount.Code code = Discount.Code.values()[random.nextInt(Discount.Code.values().length)];
//        System.out.println(String.format("s%:%.2f:%s", name, price, code));
        System.out.println(name + ":" + price + ":" +  code);
        return name + ":" + price + ":" +  code;
    }

}