### 模擬 作為使用 `CompletableFuture` 將一系列操作組合的示例，讓我們模擬一下制作蛋糕的過程。在第一階段，我們準備并將原料混合成面糊: ```java // concurrent/Batter.java import java.util.concurrent.*; import onjava.Nap; public class Batter { static class Eggs { } static class Milk { } static class Sugar { } static class Flour { } static <T> T prepare(T ingredient) { new Nap(0.1); return ingredient; } static <T> CompletableFuture<T> prep(T ingredient) { return CompletableFuture .completedFuture(ingredient) .thenApplyAsync(Batter::prepare); } public static CompletableFuture<Batter> mix() { CompletableFuture<Eggs> eggs = prep(new Eggs()); CompletableFuture<Milk> milk = prep(new Milk()); CompletableFuture<Sugar> sugar = prep(new Sugar()); CompletableFuture<Flour> flour = prep(new Flour()); CompletableFuture .allOf(eggs, milk, sugar, flour) .join(); new Nap(0.1); // Mixing time return CompletableFuture.completedFuture(new Batter()); } } ``` 每種原料都需要一些時間來準備。`allOf()` 等待所有的配料都準備好，然后使用更多些的時間將其混合成面糊。接下來，我們把單批面糊放入四個平底鍋中烘烤。產品作為 `CompletableFutures` 流返回： ```java // concurrent/Baked.java import java.util.concurrent.*; import java.util.stream.*; import onjava.Nap; public class Baked { static class Pan { } static Pan pan(Batter b) { new Nap(0.1); return new Pan(); } static Baked heat(Pan p) { new Nap(0.1); return new Baked(); } static CompletableFuture<Baked> bake(CompletableFuture<Batter> cfb) { return cfb .thenApplyAsync(Baked::pan) .thenApplyAsync(Baked::heat); } public static Stream<CompletableFuture<Baked>> batch() { CompletableFuture<Batter> batter = Batter.mix(); return Stream.of( bake(batter), bake(batter), bake(batter), bake(batter) ); } } ``` 最后，我們制作了一批糖，并用它對蛋糕進行糖化： ```java // concurrent/FrostedCake.java import java.util.concurrent.*; import java.util.stream.*; import onjava.Nap; final class Frosting { private Frosting() { } static CompletableFuture<Frosting> make() { new Nap(0.1); return CompletableFuture .completedFuture(new Frosting()); } } public class FrostedCake { public FrostedCake(Baked baked, Frosting frosting) { new Nap(0.1); } @Override public String toString() { return "FrostedCake"; } public static void main(String[] args) { Baked.batch().forEach( baked -> baked .thenCombineAsync(Frosting.make(), (cake, frosting) -> new FrostedCake(cake, frosting)) .thenAcceptAsync(System.out::println) .join()); } } ``` 一旦你習慣了這種背后的想法, `CompletableFuture` 它們相對易于使用。