CompletableFuture 使用指南与案例

一、创建异步任务
supplyAsync
runAsync
二、异步回调
thenApply
thenAccept
thenRun
exceptionally
whenComplete
handle
三、联合处理
双CompletableFuture联合处理
thenCombine
thenAcceptBoth
runAfterBoth
applyToEither
acceptEither
runAfterEither
thenCompose
四、多CompletableFuture联合处理
allOf
anyOf

一、创建异步任务

1. supplyAsync

异步执行有返回值的任务

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        throw new IllegalStateException(e);
    }
    return "Hello";
});

System.out.println(future.get()); // 输出: Hello

2. runAsync

异步执行无返回值的任务

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        throw new IllegalStateException(e);
    }
    System.out.println("任务完成");
});

future.get(); // 等待任务完成

二、异步回调

1. thenApply

转换结果

CompletableFuture<String> welcomeFuture = CompletableFuture.supplyAsync(() -> {
    return "World";
}).thenApply(name -> {
    return "Hello " + name;
});

System.out.println(welcomeFuture.get()); // 输出: Hello World

2. thenAccept

消费结果

CompletableFuture.supplyAsync(() -> {
    return "World";
}).thenAccept(name -> {
    System.out.println("Hello " + name); // 输出: Hello World
}).get();

3. thenRun

不消费结果，执行后续操作

CompletableFuture.supplyAsync(() -> {
    return "World";
}).thenRun(() -> {
    System.out.println("任务完成"); // 输出: 任务完成
}).get();

4. exceptionally

异常处理

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (true) throw new RuntimeException("出错了!");
    return "Success";
}).exceptionally(ex -> {
    System.out.println("异常: " + ex.getMessage()); // 输出: 异常: java.lang.RuntimeException: 出错了!
    return "Fallback";
});

System.out.println(future.get()); // 输出: Fallback

5. whenComplete

无论成功或异常都会执行

CompletableFuture.supplyAsync(() -> {
    return "Success";
}).whenComplete((res, ex) -> {
    if (ex != null) {
        System.out.println("异常: " + ex.getMessage());
    } else {
        System.out.println("结果: " + res); // 输出: 结果: Success
    }
}).get();

6. handle

无论成功或异常都会执行并可返回新结果

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return "Success";
}).handle((res, ex) -> {
    if (ex != null) {
        return "Fallback";
    }
    return res + " handled";
});

System.out.println(future.get()); // 输出: Success handled

三、双CompletableFuture联合处理

1. thenCombine

合并两个独立任务的结果

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");

CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (res1, res2) -> res1 + " " + res2);

System.out.println(combinedFuture.get()); // 输出: Hello World

2. thenAcceptBoth

消费两个任务的结果

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");

future1.thenAcceptBoth(future2, (res1, res2) -> {
    System.out.println(res1 + " " + res2); // 输出: Hello World
}).get();

3. runAfterBoth

两个任务都完成后执行操作

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");

future1.runAfterBoth(future2, () -> {
    System.out.println("两个任务都完成了"); // 输出: 两个任务都完成了
}).get();

4. applyToEither

使用最先完成的任务结果

CompletableFuture<String> fastFuture = CompletableFuture.supplyAsync(() -> {
    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {}
    return "Fast";
});
CompletableFuture<String> slowFuture = CompletableFuture.supplyAsync(() -> {
    try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) {}
    return "Slow";
});

CompletableFuture<String> resultFuture = fastFuture.applyToEither(slowFuture, res -> res + " wins");

System.out.println(resultFuture.get()); // 输出: Fast wins

5. acceptEither

消费最先完成的任务结果

CompletableFuture<String> fastFuture = CompletableFuture.supplyAsync(() -> {
    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {}
    return "Fast";
});
CompletableFuture<String> slowFuture = CompletableFuture.supplyAsync(() -> {
    try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) {}
    return "Slow";
});

fastFuture.acceptEither(slowFuture, res -> {
    System.out.println(res + " wins"); // 输出: Fast wins
}).get();

6. runAfterEither

任一任务完成后执行操作

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {}
    return "Hello";
});
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) {}
    return "World";
});

future1.runAfterEither(future2, () -> {
    System.out.println("有一个任务完成了"); // 输出: 有一个任务完成了
}).get();

7. thenCompose

将前一个任务的返回结果作为下一个任务的输入

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
    .thenCompose(res -> CompletableFuture.supplyAsync(() -> res + " World"));

System.out.println(future.get()); // 输出: Hello World

四、多CompletableFuture联合处理

1. allOf

等待所有任务完成

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");
CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> "!");

CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2, future3);

allFutures.thenRun(() -> {
    System.out.println("所有任务完成");
    try {
        System.out.println(future1.get() + " " + future2.get() + future3.get()); // 输出: Hello World!
    } catch (Exception e) {
        e.printStackTrace();
    }
}).get();

2. anyOf

等待任一任务完成

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) {}
    return "Hello";
});
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {}
    return "World";
});

CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(future1, future2);

System.out.println(anyFuture.get()); // 输出: World