Primero vamos a limpiar tu código.

Definamos un método que hará el sueño, para que no enturbie el agua:

 private static void sleep(int seconds) { try { Thread.sleep(TimeUnit.SECONDS.toMillis(seconds)); } catch (InterruptedException ex) { throw new RuntimeException(ex); } }

Luego, separemos las tareas y usemos los métodos adecuados:

 private static CompletableFuture<Void> task1() { return CompletableFuture.runAsync(() -> { System.out.println(" task1 start"); sleep(5); System.out.println(" task1 done"); }); } private static CompletableFuture<Void> task2() { return CompletableFuture.runAsync(() -> { System.out.println(" task2 start"); sleep(2); System.out.println(" task2 done"); }); }

Debe comprender que el encadenamiento de métodos CompletableFuture ya hace exactamente lo que desea, ejecutan la siguiente etapa, después de que finaliza la anterior . Puede hacer que su código sea mucho, mucho más fácil con:

 public static void main(String[] args) throws Exception { testFutures(); } private static void testFutures() throws Exception { CompletableFuture<Void> both = task1().thenCompose(ignoreMe -> task2()); both.get(); System.out.println("both done"); }

Tienes dos problemas.

Primero, ha creado una condición de carrera en cuanto a cuándo se agrega task2 a su lista de futuros. En el momento de ejecutar esta línea—

 CompletableFuture.allOf(...).get();

—que llamaré getter de terminación , solo tiene task1 en la lista. Compruébelo usted mismo mostrando su tamaño:

 // wait for the calls to finish try { System.out.println("# of futures: " + futures.size()); // 1

task2 aún se ejecuta eventualmente , porque lo programó con whenComplete() . Pero no es su captador de terminación lo que lo desencadena.

Recuerde que dije que es una condición de carrera. Para demostrar esto por sí mismo, agregue un sleep() antes del captador de terminación, así:

 try { Thread.sleep(6000L); } catch (InterruptedException ex) { ex.printStackTrace(); } // wait for the calls to finish try { System.out.println("# of futures: " + futures.size()); // 2

Entonces le habrá dado suficiente tiempo para agregar task2 .

Pero aquí está la cosa. Ahora , ¿el captador de terminación activa ambas tareas?

¡Aún no! Y ese es el segundo problema: casi siempre desea usar uno de los thenRun() , thenAccept() , thenApply() , thenCompose() . Estos métodos encadenan sus futuros, es decir , hacen que cada etapa dependa de la anterior, de modo que su captador de terminación realmente espere a que se complete toda la cadena. whenComplete() es un método especial que inicia una canalización totalmente no relacionada y, por lo tanto, no se ve afectado por la terminación get() .

En su caso, desea usar thenRun() , así:

 task1.thenRun( ignore -> {

Bien, entonces, ¿cómo combinamos todo eso?

 public static void testFutures () throws Exception { CompletableFuture<Void> task1 = CompletableFuture.supplyAsync( () -> { System.out.println(" task1 start"); try { Thread.sleep(5000L); } catch (InterruptedException ex) { ex.printStackTrace(); } System.out.println(" task1 done"); return null; }); CompletableFuture<Void> futuresChain = task1.thenRun( () -> { System.out.println(" task2 start"); try { Thread.sleep(2000L); } catch (InterruptedException ex) { ex.printStackTrace(); } System.out.println(" task2 done"); }); // wait for the calls to finish try { futuresChain.thenRun( () -> { System.out.println(" all tasks done "); }).toCompletableFuture().get(); } catch (Exception e) { e.printStackTrace(); } }

Producción:

 task1 start task1 done task2 start task2 done all tasks done

Verá, solo necesita supplyAsync() para la primera tarea. Desea ejecutar task2 secuencialmente después de esa tarea, entonces thenRun() hará la programación (el supplyAsync() ) por usted. Por lo tanto, tampoco necesita una serie de futuros. allOf() es para cuando desea ejecutar tareas en paralelo y esperar a que finalicen todas.