Parallel Streams

Key points

• .parallel() or parallelStream() splits the work across the shared ForkJoin common pool.
• It helps with lots of elements, real CPU work per element, and a source that splits cheaply: arrays, ranges, ArrayList.
• It hurts with small data, trivial operations, linked or iterator-based sources, and anything that blocks on I/O.
• The common pool is process-wide. One slow parallel stream starves every other one in the JVM.
• Ordered terminal ops still return the right order. forEach promises nothing in parallel; forEachOrdered does.
• Never mutate shared state from a parallel lambda. Use collect or reduce with an associative operator.

Example

import java.util.*;
import java.util.concurrent.*;
import java.util.stream.*;

public class Main {
    public static void main(String[] args) {
        long n = 5_000_000L;

        long sequential = LongStream.rangeClosed(1, n).map(i -> i * 2).sum();
        long parallel = LongStream.rangeClosed(1, n).parallel().map(i -> i * 2).sum();

        System.out.println("cores          : " + Runtime.getRuntime().availableProcessors());
        System.out.println("common pool    : " + ForkJoinPool.getCommonPoolParallelism());
        System.out.println("sequential sum : " + sequential);
        System.out.println("parallel sum   : " + parallel);
        System.out.println("same answer    : " + (sequential == parallel));

        // Ordered terminal ops still hand back the original order.
        System.out.println("toList order   : " + IntStream.rangeClosed(1, 8).parallel().boxed().toList());

        // forEach makes no ordering promise in parallel. forEachOrdered does.
        StringBuilder sb = new StringBuilder();
        IntStream.rangeClosed(1, 8).parallel().forEachOrdered(sb::append);
        System.out.println("forEachOrdered : " + sb);
    }
}

Parallel is a tuning decision, not a speed switch. Benchmark it or leave it off.