Parallel vs Sequential Stream in Java

In Java, a stream is an assortment of objects that can perform different operations on a data source, like an array or collection, and can support different methods. It was first included in the java.util.stream package in Java 8. Numerous aggregate operations, such as filter, map, limit, reduce, find, and match, are supported by streams, allowing programmers to alter the original data in any way they see fit. Since an operation given to a stream does not change its source, a new stream is generated based on the action carried out on it. The updated information is a modified duplicate of the initial format.

In accordance with its captivating characteristic, Java has had stream APIs for a very long time. Its enhanced performance and parallel processing capabilities have also made it extremely popular. Since almost every modern system in the modern era has several cores, parallel streams are necessary to exploit these cores efficiently, yet parallel programming design is difficult. Therefore, depending on the needs, the programmer has complete control over whether to employ sequential or parallel streams.

Sequential Stream :

Sequential streams are non-parallel streams that handle the pipelining using a single thread. A stream is considered sequential if any stream action is not specifically designated as parallel. Even though the underlying system enables parallel execution, a sequential stream never makes use of a multi-core processor because its objects are pipelined in a single stream on the same processing system. Operation is carried out one by one by the sequential stream. A sequential stream in Java is returned by the stream() function.

Example:

In this example, the print() function is used in combination with the list. stream() to operate one after another on a single common thread. The output of the original program displays the list's the contents in an ordered sequence simply because the stream is sequential.

Implementation:

FileName: SequentialStreamExample.java

import java.io.*; 
import java.util.*; 
import java.util.stream.*; 
public class SequentialStreamExample 
{
	public static void main(String[] args) 
	{ 
		//Create a list 
		List<String> my_list = Arrays.asList( "Hello Welcome to ", "W", "O", "R", "L", "D!"); 
		// The stream() function is being used
		// for consecutive streams.Each element 
		// of the stream should be iterated
		// through and displayed. 
		my_list.stream().forEach(System.out::print); 
	} 
}

Output:

Hello Welcome to WORLD!

Parallel Stream in Java:

While parallel computation may not be used throughout the program, it is still a highly helpful feature of Java. Performance is improved by parallel streams' use of multi-core CPUs. The final result is displayed as a composite of the results from each individual core. This can be accomplished by using parallel streams, which divide our code into many streams that can be processed concurrently on different system cores. A program does not always need to be parallelized in its completeness; however, the portions that handle the stream should be parallelized. They are complicated and prone to errors, just like any other parallel programming, but we have no control over the sequence in which they are executed. This might result in erratic, unpredictable results.

Two methods to carry out so have been provided by the Java Stream Library quickly and with consistent behavior.

Using the Collection interface's parallelStream() function is one of the simplest ways to obtain a parallel stream.
Using a sequential stream to call the BaseStream interface's parallel() method provides an additional method.

The parallel streams need to be stateless, non-interfering, and associative in order to make sure that the result that they provide is the same as that which has been obtained through the sequential stream.

Example:

As we can see, the order is not kept consistent with the list. Many threads are used in parallel operation by using the parallelStream(). It is also readily apparent that if we execute this code more than once that, the output changes in terms of order. However, since this parallel stream improves efficiency, it is advisable to utilize this technique in situations when order is irrelevant.

Implementation:

FileName: ParallelStreamExample.java

import java.io.*; 
import java.util.*; 
import java.util.stream.*; 
public class ParallelStreamExample 
{
	public static void main(String[] args) 
	{ 
		//Create a list 
		List<String> my_list = Arrays.asList( "Hello Welcome to ", "W", "O", "R", "L", "D!"); 
		// The parallelStream() function is being used
		// for consecutive streams.Each element 
		// of the stream should be iterated
		// through and displayed. 
		my_list.parallelStream().forEach(System.out::print); 
	} 
}

Output:

RLHello Welcome to OD!W

Note: The forEachOrdered() function can be used in place of the forEach() method if we wish to organize every element in the parallel stream. Observe the following program.

Implementation:

FileName: ParallelStreamExample2.java

import java.io.*; 
import java.util.*; 
import java.util.stream.*; 
public class ParallelStreamExample2 
{
	public static void main(String[] args) 
	{ 
		// create a list 
		List<String> my_list = Arrays.asList( "Hello Welcome to ", "W", "O", "R", "L", "D!"); 
		// The parallelStream() function is being used
		// for consecutive streams.Each element 
		// of the stream should be iterated
		// through and displayed. 
		my_list.parallelStream().forEachOrdered(System.out::print); 
	} 
}

Output:

Hello Welcome to WORLD!

Differences between Sequential Stream and Parallel Stream in Java

Sequential Stream	Parallel Stream
Operates on a single computer core.	Make use of the computer's numerous cores.
The performance is poor.	It's a really good performance.
There is order.	Does not give any concern about the order.
Only one iteration at a time, in line with the for-loop.	Use several available cores to run several iterations concurrently.
Every iteration waits for the one that is presently running to finish.	Waits only in the event that no free or available cores are present at a certain moment.
Less inaccuracy and more dependability.	Less trustworthy and prone to mistakes.
Platform independent.	Platform dependent.