0Pricing
Java Academy · Aula

Criando streams paralelos

parallel() e parallelStream().

Criando streams paralelos é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O que os fluxos paralelos fazem

Um fluxo paralelo divide seus dados e processa partes em várias linhas de execução, combinando os resultados depois. O objetivo é obter maior vazão em cargas de trabalho grandes.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.rangeClosed(1, 1000)
            .parallel()
            .sum();
        System.out.println(sum);
    }
}

parallel() em um fluxo existente

Chamar parallel() transforma um fluxo sequencial em um fluxo paralelo. A chamada pode aparecer em qualquer ponto da cadeia de processamento.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4, 5);
        int total = nums.stream()
            .parallel()
            .mapToInt(Integer::intValue)
            .sum();
        System.out.println(total);
    }
}

parallelStream() em coleções

Collection.parallelStream() cria diretamente um fluxo paralelo, como um atalho para stream().parallel().

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("a", "bb", "ccc");
        int chars = words.parallelStream()
            .mapToInt(String::length)
            .sum();
        System.out.println(chars);
    }
}

Voltando ao sequencial

sequential() reverte um fluxo para a execução em uma única linha de execução. A última chamada a parallel() ou sequential() prevalece em toda a cadeia de processamento.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.rangeClosed(1, 100)
            .parallel()
            .sequential()
            .sum();
        System.out.println(sum);
    }
}

Verificando isParallel

isParallel() informa se um fluxo será executado em paralelo.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        System.out.println(IntStream.range(0, 10).isParallel());
        System.out.println(IntStream.range(0, 10).parallel().isParallel());
    }
}

Mesmo resultado, execução diferente

Para operações associativas, como soma, fluxos paralelos e sequenciais retornam o mesmo resultado. Somente a estratégia de execução é diferente.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int seq = IntStream.rangeClosed(1, 50).sum();
        int par = IntStream.rangeClosed(1, 50).parallel().sum();
        System.out.println(seq == par);
    }
}

O ForkJoinPool comum

Os fluxos paralelos usam o ForkJoinPool.commonPool() compartilhado. O tamanho padrão é o número de processadores disponíveis menos um.

public class Main {
    public static void main(String[] args) {
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

A ordem das linhas de execução não é garantida

Com forEach, os fluxos paralelos podem exibir os resultados em qualquer ordem, pois as partes terminam em momentos diferentes. Use forEachOrdered se a ordem for importante.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.rangeClosed(1, 5)
            .parallel()
            .forEachOrdered(System.out::println);
    }
}

A redução combina resultados parciais

Internamente, a redução paralela calcula resultados parciais por parte e os combina com o combinador. Para garantir a correção, a operação precisa ser associativa.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int product = IntStream.rangeClosed(1, 6)
            .parallel()
            .reduce(1, (a, b) -> a * b);
        System.out.println(product);
    }
}

Coletando em paralelo

A estrutura de coletores aceita a coleta paralela ao combinar contêineres parciais. groupingBy funciona corretamente em paralelo.

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

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("apple", "banana", "avocado", "cherry");
        Map<Character, List<String>> byFirst = words.parallelStream()
            .collect(Collectors.groupingBy(w -> w.charAt(0)));
        System.out.println(byFirst);
    }
}

Nem todo fluxo fica mais rápido

Ativar o paralelismo é simples, mas nem sempre traz benefícios. Conjuntos de dados pequenos ou operações baratas podem ser mais lentos em paralelo devido ao custo adicional de divisão e combinação.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long count = IntStream.rangeClosed(1, 10)
            .parallel()
            .filter(n -> n % 2 == 0)
            .count();
        System.out.println(count);
    }
}

Verificação rápida

Qual conjunto de linhas de execução executa os fluxos paralelos por padrão?

Recapitulação

Você criou fluxos paralelos:

  • parallel() converte qualquer fluxo; parallelStream() é um atalho para coleções.
  • sequential() reverte a alteração; a última chamada prevalece.
  • Eles são executados no ForkJoinPool.commonPool() compartilhado.
  • Os resultados coincidem com os sequenciais em operações associativas, mas a ordem e a velocidade não são garantidas.

Perguntas Frequentes

A aula “Criando streams paralelos” é grátis?

Sim — o texto completo de “Criando streams paralelos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Criando streams paralelos”?

parallel() e parallelStream(). Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Criando streams paralelos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Criando streams paralelos
  2. Quando o paralelismo ajuda
  3. Segurança de threads e efeitos colaterais
  4. Armadilhas comuns
← Voltar para Java Academy