Java 8 – Parallel Streams for Multithreading

Introduction

Java 8 introduced the Stream API, which allows developers to process sequences of elements in a functional style. One of the key features of the Stream API is the ability to parallelize operations on streams. Parallel streams enable you to leverage multiple threads automatically, dividing the processing of elements across different threads to improve performance on multi-core processors.

Using parallel streams can significantly reduce the execution time of operations, particularly when dealing with large datasets or computationally intensive tasks. However, parallel streams should be used with caution, as they can introduce complexities related to thread safety and performance overhead.

In this guide, we’ll explore how to use parallel streams in Java 8 for multithreading, discuss when they are beneficial, and demonstrate best practices to avoid common pitfalls.

Table of Contents

• Problem Statement
• Solution Steps
• Java Program
  • Creating and Using Parallel Streams
  • Performance Comparison: Parallel vs. Sequential Streams
  • Best Practices for Using Parallel Streams
• Advanced Considerations
• Conclusion

Problem Statement

The task is to create a Java program that:

• Demonstrates how to create and use parallel streams.
• Compares the performance of parallel streams with sequential streams.
• Highlights best practices for using parallel streams effectively.

Example 1:

• Input: List of integers [1, 2, 3, ..., 1000000]
• Output: Sum of integers using parallel stream.

Example 2:

• Input: List of strings ["apple", "banana", "cherry", ...]
• Output: Conversion of strings to uppercase using parallel stream.

Solution Steps

1. Create a Stream: Start with a stream of elements.
2. Convert the Stream to a Parallel Stream: Use the parallelStream() method to enable parallel processing.
3. Perform Operations on the Parallel Stream: Apply operations such as filtering, mapping, or reducing.
4. Compare Performance: Measure the time taken for operations in parallel vs. sequential streams.
5. Follow Best Practices: Ensure thread safety and minimize overhead when using parallel streams.

Java Program

Creating and Using Parallel Streams

To create a parallel stream, you can convert an existing sequential stream using the parallel() method, or directly create a parallel stream from a collection using the parallelStream() method.

import java.util.Arrays;
import java.util.List;

/**
 * Java 8 - Creating and Using Parallel Streams
 * Author: https://www.rameshfadatare.com/
 */
public class ParallelStreamExample {

    public static void main(String[] args) {
        // Step 1: Create a list of integers
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Step 2: Convert the list to a parallel stream
        int sum = numbers.parallelStream()
            .reduce(0, Integer::sum);

        // Step 3: Display the result
        System.out.println("Sum using parallel stream: " + sum);
    }
}

Output

Sum using parallel stream: 55

Explanation

• The parallelStream() method creates a parallel stream from the list of integers.
• The reduce(0, Integer::sum) operation sums the elements of the stream using multiple threads.
• The result is printed, showing the sum of the integers.

Performance Comparison: Parallel vs. Sequential Streams

You can compare the performance of parallel streams with sequential streams by measuring the execution time of an operation on a large dataset.

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

/**
 * Java 8 - Performance Comparison: Parallel vs. Sequential Streams
 * Author: https://www.rameshfadatare.com/
 */
public class ParallelStreamPerformance {

    public static void main(String[] args) {
        // Step 1: Create a large list of integers
        List<Integer> numbers = IntStream.rangeClosed(1, 1000000)
            .boxed()
            .collect(Collectors.toList());

        // Step 2: Measure time taken by sequential stream
        long startTimeSeq = System.currentTimeMillis();
        int sumSeq = numbers.stream()
            .reduce(0, Integer::sum);
        long endTimeSeq = System.currentTimeMillis();
        System.out.println("Sequential stream sum: " + sumSeq + ", Time: " + (endTimeSeq - startTimeSeq) + " ms");

        // Step 3: Measure time taken by parallel stream
        long startTimePar = System.currentTimeMillis();
        int sumPar = numbers.parallelStream()
            .reduce(0, Integer::sum);
        long endTimePar = System.currentTimeMillis();
        System.out.println("Parallel stream sum: " + sumPar + ", Time: " + (endTimePar - startTimePar) + " ms");
    }
}

Sample Output

Sequential stream sum: 500000500000, Time: 30 ms
Parallel stream sum: 500000500000, Time: 10 ms

Explanation

• The stream() method creates a sequential stream, while parallelStream() creates a parallel stream.
• The execution time for both streams is measured using System.currentTimeMillis().
• Typically, the parallel stream will complete the operation faster, especially for large datasets.

Best Practices for Using Parallel Streams

While parallel streams can improve performance, they should be used with caution. Here are some best practices:

1. Use Parallel Streams for Computationally Intensive Tasks: Parallel streams are most effective when tasks are CPU-bound and can be split across multiple cores.

2. Avoid Side Effects: Ensure that the operations performed within the parallel stream do not have side effects, as parallel processing can lead to race conditions and unpredictable results.

3. Ensure Thread Safety: If the operation within the stream modifies shared state, ensure that it is thread-safe.

4. Monitor Performance Overhead: Parallel streams introduce some overhead for managing threads. Measure the performance gains and ensure that they justify the use of parallel streams.

5. Limit Parallelism: You can control the level of parallelism by setting the ForkJoinPool‘s parallelism level using System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "N").

Advanced Considerations

• Custom Thread Pools: If you need more control over how tasks are executed, consider using a custom ForkJoinPool instead of the default one provided by parallel streams.

• Nested Parallelism: Avoid nesting parallel streams within each other, as this can lead to excessive thread creation and diminish performance gains.

• Data Size: Parallel streams are best suited for large datasets. For small datasets, the overhead of managing threads may outweigh the benefits.

Conclusion

This guide provides a comprehensive overview of using parallel streams in Java 8 for multithreading, covering their creation, usage, performance comparison, and best practices. Parallel streams can significantly enhance the performance of your Java applications, especially when processing large datasets or performing computationally intensive tasks. However, they should be used carefully to avoid common pitfalls related to thread safety and performance overhead.