KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

LongAdder: verhogen, optellen en het totaal uitlezen

Met `increment()` tel je er één bij, met `add(long)` pas je een wijziging toe en met `sum()` lees je het totaal. Leer hoe je deeltotalen samenvoegt en wanneer de uitgelezen waarde exact is.

Versie: Java SE 21

Syntax

Java SE 21 — java.util.concurrent.atomic.LongAdder
public LongAdder()
public void increment()
public void add(long x)
public long sum()

LongStream.collect: (left, right) -> left.add(right.sum())

In Java SE 21 houdt java.util.concurrent.atomic.LongAdder een totaal van het type long bij dat meerdere threads kunnen bijwerken. new LongAdder() begint op nul. increment() telt er één bij, net als add(1L). add(long x) telt x erbij; die waarde mag negatief zijn. Beide methoden retourneren void. sum() retourneert een long zonder de teller op nul te zetten.

In een parallelle LongStream.collect(...) maakt LongAdder::new nieuwe containers voor deelresultaten. De accumulatiefunctie verwerkt elk element. De combinatiefunctie (left, right) -> left.add(right.sum()) leest het rechter deeltotaal en telt het op bij de linker container zonder de rechter te wijzigen. Deze overload van collect houdt de containers tijdens het verzamelen gescheiden; voor parallelle uitvoering op zich is LongAdder dus niet nodig.

Tijdens updates geeft sum() geen atomaire momentopname: wijzigingen die tijdens het uitlezen plaatsvinden, kunnen ontbreken. Lees voor een exact eindresultaat de geretourneerde container pas uit nadat collect klaar is, zoals in het voorbeeld. Beheer je de threads zelf, wacht dan met Thread.join() tot alle threads die de teller bijwerken zijn afgelopen en zorg dat geen andere thread de teller nog wijzigt.

Voorbeelden

import java.util.concurrent.atomic.LongAdder;
import java.util.stream.LongStream;

public class LongAdderDemo {
    public static void main(String[] args) {
        LongAdder total = LongStream.of(1, 4, 1, -2, 3)
                .parallel()
                .collect(LongAdder::new,
                        (partial, delta) -> {
                            if (delta == 1L) {
                                partial.increment();
                            } else {
                                partial.add(delta);
                            }
                        },
                        (left, right) -> left.add(right.sum()));

        System.out.println(total.sum());
    }
}

Resultaat

7

De verwachte uitvoer is `7`, want `1 + 4 + 1 - 2 + 3 = 7`. Het resultaat hangt niet af van de verdeling van de stream en de laatste uitlezing gebeurt nadat `collect` is teruggekeerd.

Gerelateerde lessen

  • Java · Les 24 · Gevorderd · Versie: 2

Bronnen