Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

LongAccumulator: construção, atualização e leitura do máximo

Acompanha o máximo de valores `long` com `LongAccumulator`, escolhe um elemento neutro adequado e percebe o que `get()` pode devolver durante atualizações concorrentes.

Versão: Java SE 21

Sintaxe

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();

Em Java SE 21, o construtor LongAccumulator(LongBinaryOperator,long) do pacote java.util.concurrent.atomic recebe um operador e o respetivo elemento neutro, que é também o valor inicial. Um java.util.function.LongBinaryOperator recebe dois valores primitivos long e devolve um long. O elemento neutro deixa a entrada inalterada: f(identity, x) == x.

accumulate(long x) incorpora x no cálculo através do operador e não devolve nenhum valor (void). O acumulador pode guardar os resultados parciais em separado para reduzir a contenção entre threads. Como a ordem de acumulação não é garantida, usa um operador associativo e comutativo. Evita efeitos secundários: em caso de contenção, o operador pode voltar a ser invocado.

A referência ao método Long::max seleciona o maior de dois valores. Para cobrir todo o intervalo de long, usa Long.MIN_VALUE, pois max(Long.MIN_VALUE, x) == x. 0L só é neutro para entradas não negativas, como tamanhos. Se forem possíveis entradas negativas, 0L não é um elemento neutro e Java SE 21 não garante o resultado se o usares como tal. Antes da primeira atualização, get() devolve o elemento neutro, pelo que Long.MIN_VALUE não permite, por si só, distinguir a ausência de entradas de um máximo realmente igual a esse valor.

get() combina os resultados parciais e devolve um long sem repor o estado inicial. Sem atualizações concorrentes, o resultado é exato; caso contrário, a leitura não é um retrato atómico do estado e pode omitir algumas atualizações. Usa a classe para estatísticas, não para coordenar threads. reset() repõe o elemento neutro; chama-o apenas quando nenhuma thread estiver a atualizar o acumulador.

Exemplos

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());
    }
}

Resultado

-3
-3
0

Duas leituras do mesmo acumulador dão `-3` porque `get()` não repõe o estado inicial. O segundo acumulador devolve `0` porque também recebe `0L` como entrada. Ambos usam `Long.MIN_VALUE` como elemento neutro.

Lições relacionadas

  • Java · Lição 31 · Avançado · Versão: 2

Fontes