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

CKTIS / Java

Collection.parallelStream(): processamento paralelo de fluxos

Crie, a partir de uma coleção, uma cadeia de operações que pode correr em paralelo. Distinga o modo de execução da ordem do resultado e meça se o paralelismo compensa.

Versão: Java SE 21

Sintaxe

default Stream<E> parallelStream()

Stream<E> pipeline = collection.parallelStream();

Collection.parallelStream() é um método por omissão sem argumentos de java.util.Collection<E>, disponível desde o Java 8. Devolve um Stream<E> que tem a coleção como origem. A implementação por omissão cria um fluxo paralelo a partir do seu Spliterator<E>, mas o contrato permite devolver um fluxo sequencial. Por outro lado, stream() devolve um fluxo sequencial.

As operações intermédias, como map(), são avaliadas de forma diferida: uma operação terminal como collect() dá início ao processamento. Use isParallel() antes dessa operação para consultar o modo de execução da cadeia, não para descobrir quantas threads vão trabalhar. Não reutilize o mesmo fluxo depois de uma operação terminal.

A ordem do resultado não é a ordem em que as threads trabalham. Quando a cadeia tem uma ordem de encontro definida, como acontece com uma List seguida de map(), collect(Collectors.toList()) preserva essa ordem. Collectors.toSet() não a garante, nem forEach() numa cadeia paralela. Se as ações tiverem de seguir a ordem de encontro, use forEachOrdered() num fluxo ordenado.

Não altere durante o processamento uma coleção de origem que não tenha sido concebida para acesso concorrente. Use lambdas sem estado e reúna os resultados com collect(), em vez de os adicionar a uma ArrayList partilhada a partir de forEach(). Dividir o trabalho e juntar os resultados tem um custo; uma cadeia pequena ou pouco exigente pode ser mais lenta em paralelo. Compare-a com stream() usando dados representativos.

Exemplos

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(3, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);

        List<Integer> doubled = numbers.parallelStream()
                .map(n -> n * 2)
                .collect(Collectors.toList());

        System.out.println(doubled);
    }
}

Resultado

[6, 2, 4, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26]

A cadeia duplica o valor de 13 números e reúne-os na ordem de entrada. O início `[6, 2, 4, …]` mostra que a ordem foi preservada, não que os valores foram ordenados. A saída não demonstra o uso de várias threads nem um ganho de velocidade.

Lições relacionadas

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

Fontes