KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

`CompletableFuture.thenCombine`: twee resultaten combineren

`thenCombine` maakt een nieuwe `CompletableFuture` waarvan de waarde pas wordt berekend als beide invoerstappen normaal zijn voltooid, bijvoorbeeld om twee onafhankelijke tellerstanden op te tellen.

Versie: Java SE 21

Syntax

public <U, V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other, BiFunction<? super T, ? super U, ? extends V> fn)

CompletableFuture.thenCombine registreert een functie fn die van twee stappen afhangt. De aanroep left.thenCombine(right, fn) start de invoerberekeningen niet en blokkeert ook niet om op de resultaten te wachten. fn kan pas worden uitgevoerd als beide stappen normaal zijn voltooid. De functie krijgt eerst het resultaat van left en daarna dat van right, ongeacht de volgorde waarin ze zijn voltooid.

T is het resultaattype van left en U dat van de andere stap; die typen mogen verschillen. right kan elke compatibele CompletionStage zijn en hoeft geen CompletableFuture te zijn. De waarde die de BiFunction teruggeeft, wordt het resultaat van type V van de nieuwe CompletableFuture<V>. Gebruik thenCompose als je het eerste resultaat nodig hebt om de volgende stap te kiezen of te starten.

De variant zonder Async garandeert geen aparte thread. Als beide resultaten al beschikbaar zijn, kan de functie worden uitgevoerd voordat thenCombine terugkeert. thenCombineAsync(other, fn) gebruikt het standaardmechanisme voor asynchrone uitvoering; thenCombineAsync(other, fn, executor) gebruikt de meegegeven Executor.

Als een invoerstap met een uitzondering eindigt, ook door annulering, wordt fn overgeslagen. In OpenJDK 21 wacht thenCombine tot beide invoerstappen zijn voltooid voordat de afhankelijke stap met een uitzondering wordt voltooid. Als de andere invoerstap nooit eindigt, kan de afhankelijke stap onbeperkt onafgerond blijven. Als beide mislukken, kan de gemelde oorzaak van elk van beide afkomstig zijn. Een door fn geworpen uitzondering laat de afhankelijke stap ook mislukken; bij het opvragen van zo’n resultaat werpt join() een CompletionException.

Voorbeelden

import java.util.concurrent.CompletableFuture;

public class CombineCounters {
    public static void main(String[] args) {
        var leftCount = new CompletableFuture<Integer>();
        var rightCount = new CompletableFuture<Integer>();
        CompletableFuture<Integer> total =
                leftCount.thenCombine(rightCount, Integer::sum);

        rightCount.complete(24);
        System.out.println(total.isDone());

        leftCount.complete(18);
        System.out.println(total.join());
    }
}

Resultaat

false
42

`rightCount` wordt als eerste voltooid, maar `total.isDone()` geeft nog steeds `false` terug. Pas nadat `leftCount` is voltooid, krijgt `Integer::sum` de waarden `18` en `24` en geeft `total.join()` de waarde `42` terug.

Gerelateerde lessen

  • Java · Les 51 · Gemiddeld · Versie: 2

Bronnen