Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

LongAccumulator : construction, mise à jour et lecture du maximum

Suivez le maximum de valeurs `long` avec `LongAccumulator`, choisissez un élément neutre adapté et comprenez ce que `get()` renvoie pendant des mises à jour concurrentes.

Version : Java SE 21

Syntaxe

import java.util.concurrent.atomic.LongAccumulator;
import java.util.function.LongBinaryOperator;

// API signatures
public LongAccumulator(LongBinaryOperator accumulatorFunction, long identity)
public void accumulate(long x)
public long get()

// Running maximum over the full long range
LongAccumulator maximum = new LongAccumulator(Long::max, Long.MIN_VALUE);
maximum.accumulate(-7L);
long currentMaximum = maximum.get();

Dans Java SE 21, le constructeur LongAccumulator(LongBinaryOperator,long) du paquet java.util.concurrent.atomic reçoit un opérateur et son élément neutre, qui sert aussi de valeur initiale. Un java.util.function.LongBinaryOperator prend deux valeurs primitives long et renvoie un long. L’élément neutre ne modifie pas l’entrée : f(identity, x) == x.

accumulate(long x) intègre x au calcul à l’aide de l’opérateur et ne renvoie rien (void). L’accumulateur peut conserver des résultats partiels séparés pour réduire la contention entre threads. L’ordre des opérations n’étant pas garanti, choisissez un opérateur associatif et commutatif. Il doit être sans effets de bord : la contention peut entraîner un nouvel appel.

La référence de méthode Long::max sélectionne la plus grande de deux valeurs. Pour couvrir tout l’intervalle de long, utilisez Long.MIN_VALUE, car max(Long.MIN_VALUE, x) == x. 0L n’est neutre que pour des entrées positives ou nulles, comme des tailles. Si des entrées négatives sont possibles, 0L n’est pas un élément neutre et Java SE 21 ne garantit pas le résultat si vous l’utilisez comme tel. Avant la première mise à jour, get() renvoie l’élément neutre : Long.MIN_VALUE ne suffit donc pas à distinguer l’absence d’entrées d’un maximum réellement égal à cette valeur.

get() combine les résultats partiels et renvoie un long sans réinitialiser l’accumulateur. Sans mises à jour concurrentes, le résultat est exact ; sinon, la lecture n’est pas un instantané atomique et peut omettre certaines mises à jour. Utilisez cette classe pour des statistiques, pas pour coordonner des threads. reset() rétablit l’élément neutre ; ne l’appelez que si aucun thread ne met l’accumulateur à jour.

Exemples

import java.util.concurrent.atomic.LongAccumulator;

public class Main {
    public static void main(String[] args) {
        LongAccumulator fullRange = new LongAccumulator(Long::max, Long.MIN_VALUE);
        LongAccumulator withZero = new LongAccumulator(Long::max, Long.MIN_VALUE);
        withZero.accumulate(0L);

        for (long value : new long[] {-7L, -3L, -12L}) {
            fullRange.accumulate(value);
            withZero.accumulate(value);
        }

        System.out.println(fullRange.get());
        System.out.println(fullRange.get());
        System.out.println(withZero.get());
    }
}

Résultat

-3
-3
0

Deux lectures du même accumulateur donnent `-3`, car `get()` ne réinitialise pas son état. Le second accumulateur renvoie `0` parce qu’il reçoit aussi `0L` en entrée. Les deux accumulateurs utilisent `Long.MIN_VALUE` comme élément neutre.

Leçons associées

  • Java · Leçon 31 · Avancé · Version : 2

Sources