使用 completablefuture 的 accepteither 方法可以消费最快完成的那个结果。具体做法是调用第一个 completablefuture 实例上的 accepteither,传入第二个 completablefuture 作为参数,并传递一个 consumer 函数来处理该结果。当两个任务中任意一个完成时,这个消费者就会被执行,而另一个未完成的任务会被自动取消(如果支持取消)或忽略。

如何编写 acceptEither 的基础代码
基础用法非常简单,只需将两个异步任务链式连接即可。我们创建两个模拟耗时不同的任务,通过 supplyAsync 提交到线程池。在第一个任务完成后调用 acceptEither,传入第二个任务和消费逻辑。这里的关键点是消费者只接收一个值,且该值的类型由两个 CompletableFuture 共同的返回类型决定。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class AcceptEitherDemo {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(2);
CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
try { Thread.sleep(1000); } catch (InterruptedException e) {}
return "Task 1 Result";
}, executor);
CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
try { Thread.sleep(500); } catch (InterruptedException e) {}
return "Task 2 Result";
}, executor);
// 使用 acceptEither 消费最快结果
task1.acceptEither(task2, result -> {
System.out.println("Fastest result: " + result);
});
// 保持主线程运行以便观察输出
try { Thread.sleep(2000); } catch (InterruptedException e) {}
executor.shutdown();
}
}
运行上述代码,控制台通常会打印 “Fastest result: Task 2 Result”,因为 task2 睡眠时间短,先完成。消费者函数 result -> System.out.println(...) 仅在最快任务完成时触发一次。
立即学习“Java免费学习笔记(深入)”;
如何处理异常和后续转换
如果最快的任务抛出异常,acceptEither 注册的消费者不会执行,而是会将异常传递给下一个阶段。如果需要处理这种情况,通常建议结合 exceptionally 或 handle 使用。此外,如果你不仅想消费结果,还想基于最快结果进行下一步计算,应该使用 applyToEither 而不是 acceptEither,因为后者返回 void。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExceptionHandlingDemo {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(2);
CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
throw new RuntimeException("Task 1 Failed");
}, executor);
CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
try { Thread.sleep(500); } catch (InterruptedException e) {}
return "Task 2 Success";
}, executor);
// 即使 task1 失败,只要 task2 成功,consumer 仍会执行
task1.acceptEither(task2, result -> {
System.out.println("Consumed: " + result);
}).exceptionally(ex -> {
// 只有当两个任务都失败,或者最快的是失败任务且没有后续处理时才进入
System.err.println("Exception: " + ex.getMessage());
return null;
});
try { Thread.sleep(2000); } catch (InterruptedException e) {}
executor.shutdown();
}
}
在这个例子中,task1 立即抛出异常,但 task2 正常完成。由于 acceptEither 关注的是“最快完成”而非“成功完成”,如果 task1 先完成(即使是异常状态),它可能会被视为“完成”。但在 CompletableFuture 的实现中,acceptEither 实际上等待的是任一任务完成(包括异常)。然而,消费者只在任务正常完成(非异常)时才会被调用吗?不,文档指出:如果任一 Future 完成,则执行动作。但如果完成是由于异常,动作不会被执行,异常会传播到返回的 Future。因此,在上述代码中,如果 task1 先抛异常,consumer 不会执行,exceptionally 块会捕获异常。如果 task2 先完成,consumer 执行。这体现了其“最快完成”的特性,但也需注意异常处理逻辑。
acceptEither 与 applyToEither 的区别是什么
这两个方法的核心区别在于返回值。 acceptEither 返回 CompletableFuture<void></void>,仅用于副作用(如打印、保存数据库),不产生新值。 applyToEither 返回 CompletableFuture<t></t>,它将最快任务的输出作为输入,经过一个 Function 转换后,生成一个新的 CompletableFuture。例如,如果你想获取最快结果并将其转换为大写字符串,应使用 applyToEither。
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ApplyToEitherDemo {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(2);
CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
try { Thread.sleep(1000); } catch (InterruptedException e) {}
return "hello";
}, executor);
CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
try { Thread.sleep(500); } catch (InterruptedException e) {}
return "world";
}, executor);
// 使用 applyToEither 转换最快结果
CompletableFuture<String> transformed = task1.applyToEither(task2, s -> {
return s.toUpperCase();
});
// 获取最终结果
transformed.thenAccept(result -> {
System.out.println("Transformed fastest: " + result);
});
try { Thread.sleep(2000); } catch (InterruptedException e) {}
executor.shutdown();
}
}
此代码将打印 “Transformed fastest: WORLD” 或 “HELLO”,取决于哪个任务先完成。 transformed 对象代表了转换后的结果,可以继续链式调用其他方法。这种模式适用于需要从最快响应中提取数据并进行进一步处理的场景。


















