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

CKTIS / Java

LongAdder: incrementar, adicionar e ler o total

Usa `increment()` para somar um, `add(long)` para aplicar uma variação e `sum()` para ler o total. Aprende a combinar somas parciais e a reconhecer quando a leitura dá um resultado exato.

Versão: Java SE 21

Sintaxe

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

Em Java SE 21, java.util.concurrent.atomic.LongAdder mantém um total do tipo long que várias threads podem atualizar. new LongAdder() começa em zero. increment() soma um, tal como add(1L). add(long x) soma x, que pode ser negativo. Ambos os métodos devolvem void. sum() devolve um long sem repor o contador a zero.

Num LongStream.collect(...) paralelo, LongAdder::new cria novos recipientes para os resultados parciais. A função de acumulação processa cada elemento. A função de combinação (left, right) -> left.add(right.sum()) lê a soma parcial da direita e adiciona-a ao recipiente da esquerda sem alterar o da direita. Esta sobrecarga de collect mantém os recipientes isolados durante a acumulação, pelo que a execução em paralelo não exige, por si só, LongAdder.

Durante as atualizações, sum() não fornece um instantâneo atómico: a leitura pode não incluir alterações que ocorram ao mesmo tempo. Para obter um resultado final exato, lê o recipiente devolvido depois de collect terminar, como no exemplo. Se gerires diretamente as threads, usa Thread.join() para esperar que todas as que atualizam o contador terminem e garante que nenhuma outra thread continua a alterá-lo.

Exemplos

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

Resultado

7

Espera-se que o programa escreva `7`, pois `1 + 4 + 1 - 2 + 3 = 7`. O resultado não depende da divisão do fluxo e a leitura final só ocorre depois de `collect` devolver o resultado.

Lições relacionadas

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

Fontes