Java—— CompletableFuture

最新推荐文章于 2025-05-09 16:51:49 发布

吴声子夜歌

最新推荐文章于 2025-05-09 16:51:49 发布

阅读量1.2k

点赞数 20

分类专栏： Java 文章标签： java android 数据库

本文链接：https://blog.youkuaiyun.com/cold___play/article/details/143425662

版权

CompletableFuture

1、概述

在JAVA8开始引入了全新的CompletableFuture类，它是Future接口的一个实现类。也就是在Future接口的基础上，额外封装提供了一些执行方法，用来解决Future使用场景中的一些不足，对流水线处理能力提供了支持。

在这里插入图片描述

1.1、Future接口

CompletableFuture实现自JDK 5出现的Future接口，该接口属于java.util.concurrent包，这个包提供了用于并发编程的一些基础设施，其中就包括 Future 接口。Future接口的目的是表示异步计算的结果，它允许你提交一个任务给一个 Executor（执行器），并在稍后获取任务的结果。尽管 Future 提供了一种机制来检查任务是否完成、等待任务完成，并获取其结果，但它的设计也有一些局限性，比如无法取消任务、无法组合多个任务的结果等。

public interface Future<V> {
   

    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future接口为CompletableFuture提供了以下功能：

异步任务的提交：通过Future的接口，可以提交异步任务，并在稍后获取任务的结果，这是 Future 接口最基本的功能之一。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");

检查任务完成状态：使用 isDone 方法可以检查任务是否已经完成。

boolean isDone = future.isDone();

等待任务完成：通过get方法，阻塞当前线程，直到异步任务完成并获取其结果。

System.out.println("main Thread"); 
//开启异步线程 
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello"); 
//阻塞异步线程执行完成 
String result = future.get();

取消任务：通过 cancel 方法，你可以尝试取消异步任务的执行。这是 Future 接口的一项功能，但在实际使用中，由于限制和不确定性，这个方法并不总是能够成功取消任务。

boolean canceled = future.cancel(true);

1.2、CompletionStage接口

CompletableFuture同时也实现自CompletionStage接口，CompletionStage 接口是 Java 8 中引入的，在CompletableFuture中用于表示一个步骤，这个步骤可能是由另外一个CompletionStage触发的，随当前步骤的完成，可以触发其他CompletionStage的执行。CompletableFuture 类实现了 CompletionStage 接口，因此继承了这些功能。

在这里插入图片描述

以下是 CompletionStage 为 CompletableFuture 提供的一些关键功能：

链式操作：CompletionStage 定义了一系列方法，如 thenApply, thenAccept, thenRun，允许你在一个异步操作完成后，基于其结果进行进一步的操作。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello"); 
CompletableFuture<Integer> lengthFuture = future.thenApply(String::length);

组合多个阶段：CompletionStage 提供了 thenCombine, thenCompose, thenAcceptBoth 等方法，用于组合多个阶段的结果，形成新的 CompletionStage。

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");
CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (s1, s2) -> s1 + " " + s2);
try {
   
    //Hello World
    System.out.println(combinedFuture.get());
} catch (InterruptedException e) {
   
    e.printStackTrace();
} catch (ExecutionException e) {
   
    e.printStackTrace();
}

异常处理：CompletionStage 提供了一系列处理异常的方法，如 exceptionally, handle，用于在异步计算过程中处理异常情况。

CompletableFuture<Object> future = CompletableFuture.supplyAsync(() -> {
   
    //抛出异常
    throw new RuntimeException("error");
});
CompletableFuture<Object> exceptionally = future.exceptionally(ex -> "Handled Exception: " + ex.getMessage());
try {
   
    //Handled Exception: java.lang.RuntimeException: error
    System.out.println(exceptionally.get());
} catch (InterruptedException e) {
   
    e.printStackTrace();
} catch (ExecutionException e) {
   
    e.printStackTrace();
}

顺序执行：thenApply, thenAccept, thenRun 等方法可以用于在上一个阶段完成后执行下一个阶段，形成顺序执行的链式操作。

2、CompletableFuture结构

2.1、字段和常量

字段：

//存储异步计算的结果
volatile Object result;      

//存储观察者链
volatile Completion stack; 

//空结果
static final AltResult NIL = new AltResult(null);

//默认线程池是否支持并行
private static final boolean useCommonPool =
        (ForkJoinPool.getCommonPoolParallelism() > 1);

//默认线程池
private static final Executor asyncPool = useCommonPool ?
        ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();

//Unsafe类及操作所需偏移量
private static final sun.misc.Unsafe UNSAFE;
private static final long RESULT;
private static final long STACK;
private static final long NEXT;

常量：

//这三个变量用于Completion类中tryFire方法的标志，表示不同的触发模式。
static final int SYNC   =  0;
static final int ASYNC  =  1;
static final int NESTED = -1;

SYNC：表示同步触发（默认触发方式），即当前计算完成后直接执行后续的操作。适用于当前计算的结果已经准备好并且可以直接进行下一步操作的情况。
AYSNC：表示异步触发，当前计算完成后将后续的操作提交到异步线程池中执行。即当前计算完成后将后续的操作提交到异步线程池中执行。适用于需要在不同线程上执行后续操作的情况。
NESTED：嵌套触发，通常表示当前阶段的触发是由另一个阶段触发的，因此无需再次触发后续操作。在某些情况下，可能会避免重复触发。

2.2、内部类

CompletableFuture 类包含多个内部类，这些内部类用于为CompletableFuture提供不同的API而设计的，用于异步编程中的不同阶段和操作。

常用内部类列举：

UniCompletion、BiCompletion：UniCompletion 和 BiCompletion 是用于表示异步操作链中的单一阶段和二元阶段的基础抽象类。它们提供了一些通用的方法和字段，用于处理阶段之间的关系，尤其是观察者链的构建和触发。
UniApply、UniAccept、UniRun：UniApply、UniAccept 和 UniRun 是 UniCompletion 的具体子类，分别用于表示异步操作链中的 thenApply、thenAccept 和 thenRun 阶段。它们实现了具体的 tryFire 方法，用于触发阶段的执行。
BiApply、BiAccept、BiRun：：BiApply、BiAccept 和 BiRun 是 BiCompletion 的具体子类，分别用于表示异步操作链中的 thenCombine、thenAcceptBoth 和 runAfterBoth 阶段。它们同样实现了具体的 tryFire 方法。
OrApply、OrAccept、OrRun：OrApply、OrAccept 和 OrRun 是 BiCompletion 的另一组具体子类，用于表示异步操作链中的 applyToEither、acceptEither 和 runAfterEither 阶段。同样，它们实现了具体的 tryFire 方法。

abstract CompletableFuture<?> tryFire(int mode);

.触发方式（ mode ）：tryFire 方法接收一个 mode 参数，表示触发的方式。常见的触发方式包括同步触发（SYNC）、异步触发（ASYNC）以及嵌套触发（NESTED）。
.触发下一个阶段：在 tryFire 方法中，通过 next 字段获取下一个阶段的引用，然后调用下一个阶段的 tryFire 方法，将当前阶段的计算结果传递给下一个阶段。
递归触发：tryFire 方法可能会递归调用下一个阶段的 tryFire 方法，以确保整个异步操作链中的阶段能够依次触发。这个递归调用保证了异步操作链的串联执行。
触发逻辑的条件判断：tryFire 方法中通常还包含一些条件判断，用于确定是否应该触发后续的操作。例如，可能会检查当前阶段的状态，如果满足触发条件，则继续触发。

总体而言，tryFire 方法是 CompletableFuture 异步操作链中触发后续阶段的核心方法。通过递归调用，它实现了异步操作链的顺序执行，确保了各个阶段按照期望的顺序执行，并将计算结果传递给下一个阶段。

3、CompletableFuture原理

3.1、设计思想

CompletableFuture 按照类似“观察者模式”的设计思想，原理分析可以从“观察者”和“被观察者”两个方面着手。

CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
   //fn1函数
   return "hello world";
});
CompletableFuture<String> cf2 = cf1.thenApply(e -> {
   //fn2函数
    return e + "!!!";
});
try {
   
	//hello world!!!
    System.out.println(cf2.get());
} catch (InterruptedException e) {
   
    e.printStackTrace();
} catch (ExecutionException e) {
   
    e.printStackTrace();
}

在这里插入图片描述

由于回调种类多，但结构差异不大，所以这里单以一元依赖中的thenApply为例，不再枚举全部回调类型。

被观察者：

每个CompletableFuture都可以被看作一个被观察者，其内部有一个Completion类型的链表成员变量stack，用来存储注册到其中的所有观察者。当被观察者执行完成后会弹栈stack属性，依次通知注册到其中的观察者。上面例子中步骤fn2就是作为观察者被封装在UniApply中。
被观察者CF中的result属性，用来存储返回结果数据。这里可能是一次RPC调用的返回值，也可能是任意对象，在上面的例子中对应步骤fn1的执行结果。

观察者：
CompletableFuture支持很多回调方法，例如thenAccept、thenApply、exceptionally等，这些方法接收一个函数类型的参数f，生成一个Completion类型的对象（即观察者），并将入参函数f赋值给Completion的成员变量fn，然后检查当前CF是否已处于完成状态（即result!=null），如果已完成直接触发fn，否则将观察者Completion加入到CF的观察者链stack中，再次尝试触发，如果被观察者未执行完则其执行完毕之后通知触发。

观察者中的dep属性：指向其对应的CompletableFuture，在上面的例子中dep指向CF2。
观察者中的src属性：指向其依赖的CompletableFuture，在上面的例子中src指向CF1。
观察者Completion中的fn属性：用来存储具体的等待被回调的函数。这里需要注意的是不同的回调方法（thenAccept、thenApply、exceptionally等）接收的函数类型也不同，即fn的类型有很多种，在上面的例子中fn指向fn2。

3.2、获取任务结果的实现

先来分析一下CompletableFuture的get方法的实现细节，CompletableFuture实现了Future的所有接口,包括两个get方法，一个是不带参数的get方法，一个是可以设置等待时间的get方法。

不带参数的Get方法实现

首先来看一下CompletableFuture中不带参数的get方法的具体实现：

public T get() throws InterruptedException, ExecutionException {
   
    Object r;
    return reportGet((r = result) == null ? waitingGet(true) : r);
}

result字段代表任务的执行结果，所以首先判断是否为null，为null则表示任务还没有执行结束，那么就会调用waitingGet方法来等待任务执行完成，如果result不为null，那么说明任务已经成功执行结束了，那么就调用reportGet来返回结果，下面先来看一下waitingGet方法的具体实现细节：

private Object waitingGet(boolean interruptible) {
   
    Signaller q = null;
    boolean queued = false;
    int spins = -1;
    Object r;
    while ((r = result) == null) {
   
        if (spins < 0)
            spins = (Runtime.getRuntime().availableProcessors() > 1) ?
                1 << 8 : 0; // Use brief spin-wait on multiprocessors
        else if (spins > 0) {
   
            if (ThreadLocalRandom.nextSecondarySeed() >= 0)
                --spins;
        }
        else if (q == null)
            q = new Signaller(interruptible, 0L, 0L);
        else if (!queued)
            queued = tryPushStack(q);
        else if (interruptible && q.interruptControl < 0) {
   
            q.thread = null;
            cleanStack();
            return null;
        }
        else if (q.thread != null && result == null) {
   
            try {
   
                ForkJoinPool.managedBlock(q);
            } catch (InterruptedException ie) {
   
                q.interruptControl = -1;
            }
        }
    }
    if (q != null) {
   
        q.thread = null;
        if (q.interruptControl < 0) {
   
            if (interruptible)
                r = null; // report interruption
            else
                Thread.currentThread().interrupt();
        }
    }
    postComplete();
    return r;
}

这个方法的实现时比较复杂的，方法中有几个地方需要特别注意，下面先来看一下spins是做什么的，根据注释，可以知道spins是用来在多核心环境下的自旋操作的，所谓自旋就是不断循环等待判断，从代码可以看出在多核心环境下，spins会被初始化为1 << 8，然后在自旋的过程中如果发现spins大于0，那么就通过一个关键方法ThreadLocalRandom.nextSecondarySeed()来进行spins的更新操作，如果ThreadLocalRandom.nextSecondarySeed()返回的结果大于0，那么spins就减1，否则不更新spins。ThreadLocalRandom.nextSecondarySeed()方法其实是一个类似于并发环境下的random，是线程安全的。

接下来还需要注意的一个点是Signaller，从Signaller的实现上可以发现，Signaller实现了ForkJoinPool.ManagedBlocker，下面是ForkJoinPool.ManagedBlocker的接口定义：

 public static interface ManagedBlocker {
   

        boolean block() throws InterruptedException;

        boolean isReleasable();
    }

ForkJoinPool.ManagedBlocker的目的是为了保证ForkJoinPool的并行性，具体分析还需要更为深入的学习Fork/Join框架。

继续回到waitingGet方法中，在自旋过程中会调用ForkJoinPool.managedBlock(ForkJoinPool.ManagedBlocker)来进行阻塞工作，实际的效果就是让线程等任务执行完成，CompletableFuture中与Fork/Join的交叉部分内容不再本文的描述范围，日后再进行分析总结。总得看起来，waitingGet实现的功能就是等待任务执行完成，执行完成返回结果并做一些收尾工作。

现在来看reportGet方法的实现细节，在判断任务执行完成之后，get方法会调用reportGet方法来获取结果：

private static <T> T reportGet(Object r)
    throws InterruptedException, ExecutionException {
   
    if (r == null) // by convention below, null means interrupted
        throw new InterruptedException();
    if (r instanceof AltResult) {
   
        Throwable x, cause;
        if ((x = ((AltResult)r).ex) == null)
            return null;
        if (x instanceof CancellationException)
            throw (CancellationException)x;
        if ((x instanceof CompletionException) &&
            (cause = x.getCause()) != null)
            x = cause

最低0.47元/天解锁文章