【JUC】8-CompletableFutrue的常用方法

1、获得结果和触发计算

获得结果

public T get()

public T get(long timeOut, Timeunit unit)

public T join()

public getNow(T valueIfAbsent)

主动触发计算

public boolean complete(T value)

 

2、对计算结果进行处理

计算结果存在依赖关系，这两个线程串行化

thenApply()

计算结果存在依赖关系，这两个线程串行化，步骤有异常也可以往下走，根据带的异常参数可以进一步往下走

handle()

 

示例代码

package com.heima.Thread;

import java.util.concurrent.*;

public class CompletableFutureApiDemo {
    private static final ExecutorService THREAD_POOL = Executors.newFixedThreadPool(3);

    public static void main(String[] args) {
        try {
            // public T getNow(T valueIfAbsent)
            test_getNow();
            // public boolean complete(T value)  是否打断get()方法立即返回括号值
            test_complete();
            // thenApply() 计算结果存在依赖关系，这两个线程串行化
            test_thenApply();
            // handle() 计算结果存在依赖关系，这两个线程串行化，步骤有异常也可以往下走，根据带的异常参数可以进一步往下走
            test_handle();
        } finally {
            THREAD_POOL.shutdown();
        }
    }

    private static void test_handle() {
        CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("step 1");
            return ThreadLocalRandom.current().nextInt();
        }, THREAD_POOL).handle((f, e) -> {
            int i = 10/0;
            System.out.println("step 2, get result " + f);
            return f + 2;
        }).handle((f, e) -> {
            System.out.println("step 3, get result " + f);
            return f * 3;
        }).whenComplete((v, e) -> {
            if (e == null) {
                System.out.println("result is " + v);
            }
        }).exceptionally(e -> {
            e.printStackTrace();
            System.out.println(e.getMessage());
            return null;
        });


        // CompletableFuture使用默认的ForkJoinPool时，主线程结束时，其他线程也会结束
        System.out.println("Thread " + Thread.currentThread().getName() + " process other task.");
    }

    private static void test_thenApply() {
        CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("step 1");
            return ThreadLocalRandom.current().nextInt();
        }, THREAD_POOL).thenApply(f -> {
            System.out.println("step 2, get result " + f);
            return f + 2;
        }).thenApply(f -> {
            System.out.println("step 3, get result " + f);
            return f * 3;
        }).whenComplete((v, e) -> {
            if (e == null) {
                System.out.println("result is " + v);
            }
        }).exceptionally(e -> {
            e.printStackTrace();
            System.out.println(e.getMessage());
            return null;
        });


        // CompletableFuture使用默认的ForkJoinPool时，主线程结束时，其他线程也会结束
        System.out.println("Thread " + Thread.currentThread().getName() + " process other task.");
    }


    private static void test_getNow() {

        CompletableFuture<String> result = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return "ok";
        }, THREAD_POOL);

        System.out.println(result.getNow("not ok"));

    }

    private static void test_complete() {
        CompletableFuture<String> result = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return "ok";
        }, THREAD_POOL);

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(result.complete("completable ok") + "\t" + result. Join());
    }
}

 

3、对计算结果进行消费

 

thenAccept(Consumer action) 任务A执行完执行任务B，B需要A的结果，但是任务B无返回值

 

thenRun(Runnable runnable) 任务A执行完执行B，并且B不需要A的结果

4、对计算速度进行选用

 

5、对计算结果进行合并