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