Java 8 Parallel Streams Internals (Part 1)schmidt/cs891f/2018-PDFs/07-parallelstrea… · •Recall...

Java 8 Parallel Streams Internals

(Part 1)

Douglas C. [email protected]

www.dre.vanderbilt.edu/~schmidt

Professor of Computer Science

Institute for Software

Integrated Systems

Vanderbilt University

Nashville, Tennessee, USA

mailto:[email protected]

2

• Understand parallel stream internals

Learning Objectives in this Part of the Lesson

join join

join

Processsequentially

Processsequentially

Processsequentially

Processsequentially

List<String>1.1 List<String>1.2 List<String>2.1 List<String>2.2

List<String>1 List<String>2

trySplit()

List<String>

trySplit() trySplit()

See www.ibm.com/developerworks/library/j-java-streams-3-brian-goetz

http://www.ibm.com/developerworks/library/j-java-streams-3-brian-goetz

3

• Understand parallel stream internals, e.g.

• Know what can change & what can’t

Learning Objectives in this Part of the Lesson

See en.wikipedia.org/wiki/Serenity_Prayer

https://en.wikipedia.org/wiki/Serenity_Prayer

4

Why Knowledge of Parallel Streams Matters

5

• Converting a Java 8 sequential stream to a parallel stream is usually quite straightforward

See “Java 8 SearchWithParallelStreams Example”

Why Knowledge of Parallel Streams MattersList<List<SearchResults>>

processStream() {

return getInput()

.stream()

.map(this::processInput)

.collect(toList());

}

vs

Changing stream() calls to parallelStream() calls

involves minuscule effort!!

List<List<SearchResults>>

processStream() {

return getInput()

.parallelStream()

.map(this::processInput)

.collect(toList());

}

6

• However, knowledge of parallel streams internals will make you a better Java 8 streams programmer!

join join

join

Processsequentially

Processsequentially

Processsequentially

Processsequentially

List<String>1.1 List<String>1.2 List<String>2.1 List<String>2.2

List<String>1 List<String>2

trySplit()

List<String>

trySplit() trySplit()

See www.ibm.com/developerworks/library/j-java-streams-3-brian-goetz

When performance is critical, it's importantto understand how

streams work internally

Why Knowledge of Parallel Streams Matters

http://www.ibm.com/developerworks/library/j-java-streams-3-brian-goetz

7See docs.oracle.com/javase/tutorial/collections/streams/parallelism.html

Why Knowledge of Parallel Streams Matters• Recall the 3 phases of a Java 8 parallel stream

Output

f(x)

Output

g(f(x))

…

Input x

Intermediate operation (behavior f)

Intermediate operation (behavior g)

Terminal operation (reducer)

Stream factory operation ()

https://docs.oracle.com/javase/tutorial/collections/streams/parallelism.html

8


• Split – Uses a spliterator to partition stream elements into multiple chunks

…





Output

f(x)

Output

g(f(x))

Input x

9



• Apply – Independently processes these chunks in the common fork-join pool

…





Output

f(x)

Output

g(f(x))

Input x

10




• Combine – Joins partial sub-results into a single result

…





Output

f(x)

Output

g(f(x))

Input x

11




• Combine – Joins partial sub-results into a single result

…





Output

f(x)

Output

g(f(x))

Input x

It’s important to which of these phases you can control & which you can’t!

12

Parallel Stream Splitting & Thread Pool Mechanisms

13

• A parallel stream’s splitting & thread pool mechanisms are often invisible

Parallel Stream Splitting & Thread Pool Mechanisms …



Terminal operation (behavior h)


Output

f(x)

Output

g(f(x))

Input x

14

• A parallel stream’s splitting & thread pool mechanisms are often invisible, e.g.

• Java collections have predefinedspliterators






Output

f(x)

Output

g(f(x))

Input x

See blog.logentries.com/2015/10/java-8-introduction-to-parallelism-and-spliterator

public interface Collection<E> {

default Stream<E> stream() {

return StreamSupport

.stream(spliterator(), false);

}

default Spliterator<E> spliterator() {

return Spliterators

.spliterator(this, 0);

}

}

https://blog.logentries.com/2015/10/java-8-introduction-to-parallelism-and-spliterator

15

• A parallel stream’s splitting & thread pool mechanisms are often invisible, e.g.

• Java collections have predefinedspliterators

• The common fork-join pool is used by default






Output

f(x)

Output

g(f(x))

Input x

See www.baeldung.com/java-fork-join

http://www.baeldung.com/java-fork-join

16

• However, programmers can customize thebehavior of splitting & thread pools






Output

f(x)

Output

g(f(x))

Input x

public interface ManagedBlocker {

boolean block()

throws InterruptedException;

boolean isReleasable();

}

public interface Spliterator<T> {

boolean tryAdvance

(Consumer<? Super T> action);

Spliterator<T> trySplit();

long estimateSize();

int characteristics();

}

See Parts 2 & 4 of this lesson on “Java 8 Parallel Stream Internals”

17

Parallel Stream Ordering

18

• The order in which chunks are processed is non-deterministic


Output

f(x)

Output

g(f(x))

…

Input x





See en.wikipedia.org/wiki/Nondeterministic_algorithm

The ordering can exhibit different behaviors on different runs even for the same input

https://en.wikipedia.org/wiki/Nondeterministic_algorithm

19


• Programmers have little/no control over how chunks are processed


Output

f(x)

Output

g(f(x))

…

Input x





20


• Programmers have little/no control over how chunks are processed

• Non-determinism is useful since it enables optimizations at multiple layers!


Additional Frameworks & Languages

Operating System Kernel

Applications

System Libraries

Java Execution Environment (e.g., JVM)

Threading & Synchronization Packages

e.g., scheduling & execution of tasks via fork-join pool, JVM, hardware cores, etc.

21

• The results of the processing are moredeterministic

Parallel Stream Ordering…





Output

f(x)

Output

g(f(x))

Input x

See en.wikipedia.org/wiki/Deterministic_algorithm

https://en.wikipedia.org/wiki/Deterministic_algorithm

22


• Programmers can control if results arepresented in “encounter order” (EO)






Output

f(x)

Output

g(f(x))

Input x

See www.logicbig.com/tutorials/core-java-tutorial/java-util-stream/ordering

EO is order in which the stream source makes its elements available

http://www.logicbig.com/tutorials/core-java-tutorial/java-util-stream/ordering

23



• Order is maintained if the source is ordered & the aggregate operations used are obliged to maintain order






Output

f(x)

Output

g(f(x))

Input x

See www.ibm.com/developerworks/library/j-java-streams-3-brian-goetz/index.html#eo

It doesn’t matter whether the stream is parallel or sequential

http://www.ibm.com/developerworks/library/j-java-streams-3-brian-goetz/index.html#eo

24




• Ordered spliterators, orderedcollections, & static stream factorymethods respect “encounter order”


See github.com/douglascraigschmidt/LiveLessons/tree/master/Java8/ex21

List<Integer> list =

Arrays.asList(1, 2, ...);

Integer[] doubledList = list

.parallelStream()

.filter(x -> x % 2 == 0)

.map(x -> x * 2)

.toArray(Integer[]::new);

The encounter order is [1, 2, 3, 4, …] since list is ordered

https://github.com/douglascraigschmidt/LiveLessons/tree/master/Java8/ex21

25






The result must be [2, 4, …]





.parallelStream()

.filter(x -> x % 2 == 0)

.map(x -> x * 2)



26





• Unordered collections don’t needto respect “encounter order”

Parallel Stream OrderingSet<Integer> set = new

HashSet<>

(Arrays.asList(1, 2, ...);

Integer[] doubledSet = set

.parallelStream()

.filter(x -> x % 2 == 0)

.map(x -> x * 2)



A HashSet is unordered


27





• Unordered collections don’t needto respect “encounter order”

Parallel Stream OrderingSet<Integer> set = new

HashSet<>

(Arrays.asList(1, 2, ...);

Integer[] doubledSet = set

.parallelStream()

.filter(x -> x % 2 == 0)

.map(x -> x * 2)


This code runs faster since encounter order need not be maintained



28




• Certain intermediate operations affectordering behavior






Output

f(x)

Output

g(f(x))

Input x

29





• e.g., sorted(), unordered(), skip(), & limit()



The result must be [2, 4, …], but the code is slow due to limit() & distinct() “stateful” semantics in parallel streams




.parallelStream()

.distinct()

.filter(x -> x % 2 == 0)

.map(x -> x * 2)

.limit(sOutputLimit)



30





• e.g., sorted(), unordered(), skip(), & limit()

Parallel Stream OrderingList<Integer> list =



.parallelStream()

.unordered()

.distinct()

.filter(x -> x % 2 == 0)

.map(x -> x * 2)



This code runs faster since stream is unordered & thus limit() & distinct() incur less overhead



31





• Certain terminal operations also affectordering behavior






Output

f(x)

Output

g(f(x))

Input x

32






• e.g., forEachOrdered() & forEach()

Parallel Stream OrderingList<Integer> list =


ConcurrentLinkedQueue

<Integer> queue = new

ConcurrentLinkedQueue<>();

list

.parallelStream()

.distinct()

.filter(x -> x % 2 == 0)

.map(x -> x * 2)


.forEachOrdered(queue::add);

Ordered



33






• e.g., forEachOrdered() & forEach()





ConcurrentLinkedQueue

<Integer> queue = new

ConcurrentLinkedQueue<>();

list

.parallelStream()

.distinct()

.filter(x -> x % 2 == 0)

.map(x -> x * 2)


.forEach(queue::add);

Unordered


34

End of Java 8 Parallel Stream Internals (Part 1)

Date post:	25-Aug-2020
Category:	Documents
Upload:	others
View:	5 times
Download:	1 times

Java 8 Parallel Streams Internals (Part 1)schmidt/cs891f/2018-PDFs/07-parallelstrea… · •Recall...

Documents