java异步编程历史概述

1.Java5.0之前主要是通过Thread类,Runnable接口实现，主要的缺点是无法拿到异步线程的返回值，以及异常处理

new Thread(()-> System.out.println("111111"),"java5").start();

2.java5.0增加Future，Callable。主要缺点阻塞式编程，无法进行多个异步线程之间的操作，无法异常处理

ExecutorService executorService = Executors.newSingleThreadExecutor();
Callable<String> threadTask  = ()->"java7 callable";
Future<String> submit = executorService.submit(threadTask);
System.out.printf("java7 thread ===>%s \n",submit.get());
executorService.shutdown();

3.Java7.0引入Fork/join，类似于线程池，主要是压榨本地cp。。个人感觉实际工作中应用的不多

4.引入CompletableFuture

样例一：

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(()->{
            System.out.println("java8 thread....");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "8888....";
        });

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

 

样例二：

List<Map<String, String>> result = new ArrayList<>();
        List<CompletableFuture<Boolean>> collect = Stream.of(1, 2, 3, 4, 10)
                .map(num ->
                        CompletableFuture.supplyAsync(() -> {
                            Map<String, String> hashMap = new HashMap<String, String>();
                            hashMap.put("i" + num, num + "");
                            try {
                                Thread.sleep(RandomUtils.nextInt(5000));
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            return hashMap;
                        }).thenApply(r -> result.add(r))).collect(Collectors.toList());

        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.allOf(collect.toArray(new CompletableFuture[]{}));
        voidCompletableFuture.join();

        System.out.println("===========main thread==========");
        for(Map<String,String> res:result){
            System.out.println(res.toString());
        }