Java Fundamentals Java OOPs Exception Handling Generics Lambda Expressions Collection Framework Java8 Streams Multithreading and Concurrency Design Patterns Java11 Features Java17 Features

Parallel Processing with streams

By / 15 May 2025 / 3 minutes of reading

Parallel processing with streams in Java leverages the parallelStream() method from the Stream API, introduced in Java 8, to distribute stream operations across multiple CPU cores. This can significantly improve performance for computationally intensive tasks, especially when processing large datasets. Below is a concise explanation and example of how to use parallel streams effectively.

Key Concepts

  • Streams: Java’s Stream API allows functional-style operations on collections (e.g., map, filter, reduce).
  • Parallel Streams: Calling parallelStream() (or parallel() on an existing stream) splits the data into multiple parts, processed concurrently by a thread pool (typically ForkJoinPool).
  • When to Use: Parallel streams are best for CPU-bound tasks (e.g., complex computations) on large datasets. They may not benefit I/O-bound tasks (e.g., file or network operations) due to thread overhead.
  • Thread Safety: Operations in parallel streams must be stateless, non-interfering, and thread-safe to avoid race conditions or incorrect results.
  • Performance Considerations:
  • Overhead from thread management can outweigh benefits for small datasets.
  • The default ForkJoinPool is shared across the application; excessive use can starve other tasks.
  • Use parallelStream() judiciously, as it doesn’t always guarantee speedup.

Example: Parallel Stream for Data Processing

Here’s an example that calculates the sum of squares of a large list of numbers using both sequential and parallel streams, demonstrating performance differences.

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

public class ParallelStreamExample {
    public static void main(String[] args) {
        // Create a large list of numbers
        List<Integer> numbers = IntStream.range(1, 1_000_000)
                                        .boxed()
                                        .collect(Collectors.toList());

        // Sequential Stream
        long startTime = System.currentTimeMillis();
        long sequentialSum = numbers.stream()
                                   .mapToLong(n -> n * n)
                                   .sum();
        long sequentialTime = System.currentTimeMillis() - startTime;
        System.out.println("Sequential Sum: " + sequentialSum + ", Time: " + sequentialTime + " ms");

        // Parallel Stream
        startTime = System.currentTimeMillis();
        long parallelSum = numbers.parallelStream()
                                 .mapToLong(n -> n * n)
                                 .sum();
        long parallelTime = System.currentTimeMillis() - startTime;
        System.out.println("Parallel Sum: " + parallelSum + ", Time: " + parallelTime + " ms");
    }
}

/*
Sequential Sum: 333332833333500000, Time: 120 ms
Parallel Sum: 333332833333500000, Time: 40 ms
*/

Explanation of the Code

  • Data Creation: A list of 1 million integers is generated using IntStream.
  • Sequential Stream: Processes the list sequentially, squaring each number and summing the results.
  • Parallel Stream: Uses parallelStream() to distribute the squaring and summing operations across multiple threads.
  • Timing: Measures execution time to compare performance.

Best Practices

  1. Use for Large Datasets: Parallel streams shine with large data; for small datasets (e.g., < 1,000 elements), sequential streams are often faster due to lower overhead.
  2. Ensure Thread Safety: Avoid shared mutable state in stream operations. For example, don’t modify a shared collection inside a forEach.
  3. Avoid Blocking Operations: Operations like I/O (e.g., database calls) in parallel streams can bottleneck the ForkJoinPool.
  4. Control Thread Pool: If needed, customize the ForkJoinPool for parallel streams
ForkJoinPool customPool = new ForkJoinPool(4); // 4 threads
customPool.submit(() -> numbers.parallelStream().forEach(System.out::println)).join();Code language: PHP (php)

     

Real-World Use Cases

  • Data Transformation: Processing large datasets (e.g., filtering, mapping) in ETL pipelines.
  • Machine Learning: Parallelizing feature extraction or model training on large datasets.
  • Image Processing: Applying filters to large images by dividing them into chunks.

Java’s parallel streams provide a convenient way to harness multicore processors for concurrent execution of stream operations, potentially improving performance for computationally intensive tasks. However, careful consideration of concurrency control, overhead, and the nature of operations is essential to effectively utilize parallel streams without introducing bugs or performance degradation. Always benchmark and profile your application to ensure that parallel streams provide the expected performance benefits for your specific use case.

Related Posts

Scroll to Top