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

CKTIS / Java

Respeitar a ordem de encontro com Stream.forEachOrdered

Usa `forEachOrdered` quando uma ação terminal tem de respeitar a ordem de encontro do fluxo, mesmo num pipeline paralelo. O método `forEach` não dá essa garantia em modo paralelo.

Versão: Java SE 21

Sintaxe

java.util.Collection<E>: default Stream<E> parallelStream()
java.util.stream.Stream<T>: void forEachOrdered(Consumer<? super T> action)
Contrast on java.util.stream.Stream<T>: void forEach(Consumer<? super T> action)

collection.parallelStream().forEachOrdered(action);

Em Java SE 21, Collection.parallelStream() cria um fluxo que tem a coleção como origem. A implementação predefinida cria-o em modo paralelo, mas o contrato permite devolver um fluxo sequencial. O modo paralelo não garante a utilização de várias threads nem uma execução mais rápida.

Stream.forEachOrdered(action) é uma operação terminal com tipo de retorno void. Recebe um Consumer<? super T> e executa a ação para cada elemento que chega ao fim do pipeline, respeitando a ordem de encontro se esta estiver definida. Numa List, é a ordem dos elementos na lista, e filter mantém a ordem relativa dos elementos que passam o filtro. Um HashSet não define por si só essa ordem. forEachOrdered não ordena os elementos nem cria uma ordem onde ela não existe.

As ações terminais são executadas uma de cada vez: a ação para um elemento precede, no sentido de happens-before, as ações para os elementos seguintes. As ações podem ser executadas em threads diferentes e as etapas anteriores podem continuar a executar-se em paralelo. A garantia aplica-se a estas chamadas, não a acessos independentes de outras threads ao estado partilhado.

O método Stream.forEach(action) não garante a ordem de encontro num pipeline paralelo, mesmo que por acaso a respeite numa execução. Usa-o apenas quando a ordem das ações não for relevante e garante que os acessos ao estado partilhado são seguros. Com ambos os métodos, a ação não deve interferir com a origem do fluxo. Não reutilizes o mesmo fluxo depois de uma operação terminal; cria um novo para voltar a percorrer a origem.

Exemplos

import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(5, 2, 1, 4, 3);

        numbers.parallelStream()
                .filter(n -> n % 2 != 0)
                .forEachOrdered(System.out::println);

        AtomicInteger matches = new AtomicInteger();
        numbers.parallelStream()
                .filter(n -> n % 2 != 0)
                .forEach(n -> matches.incrementAndGet());
        System.out.println("Count: " + matches.get());
    }
}

Resultado

5
1
3
Count: 3

O primeiro pipeline imprime os números ímpares pela ordem da lista: `5`, `1`, `3`, e não por ordem crescente. O segundo usa `forEach` apenas para realçar o contraste: incrementa um contador atómico, pelo que `Count: 3` não depende da ordem das ações. Se só precisares de contar, usa `count()` em vez de um contador partilhado.

Lições relacionadas

  • Java · Lição 43 · Avançado · Versão: 2
  • Java · Lição 57 · Intermédio · Versão: 2

Fontes