How to ensure order of processing in java8 streams?

by

You are asking the wrong question. You are asking about sequential vs. parallel whereas you want to process items in order, so you have to ask about ordering. If you have an ordered stream and perform operations which guarantee to maintain the order, it doesn’t matter whether the stream is processed in parallel or sequential; the implementation will maintain the order.

The ordered property is distinct from parallel vs sequential. E.g. if you call stream() on a HashSet the stream will be unordered while calling stream() on a List returns an ordered stream. Note that you can call unordered() to release the ordering contract and potentially increase performance. Once the stream has no ordering there is no way to reestablish the ordering. (The only way to turn an unordered stream into an ordered is to call sorted, however, the resulting order is not necessarily the original order).

See also the “Ordering” section of the java.util.stream package documentation.

In order to ensure maintenance of ordering throughout an entire stream operation, you have to study the documentation of the stream’s source, all intermediate operations and the terminal operation for whether they maintain the order or not (or whether the source has an ordering in the first place).

This can be very subtle, e.g. Stream.iterate(T,UnaryOperator) creates an ordered stream while Stream.generate(Supplier) creates an unordered stream. Note that you also made a common mistake in your question as forEach does not maintain the ordering. You have to use forEachOrdered if you want to process the stream’s elements in a guaranteed order.

So if your list in your question is indeed a java.util.List, its stream() method will return an ordered stream and filter will not change the ordering. So if you call list.stream().filter() .forEachOrdered(), all elements will be processed sequentially in order, whereas for list.parallelStream().filter().forEachOrdered() the elements might be processed in parallel (e.g. by the filter) but the terminal action will still be called in order (which obviously will reduce the benefit of parallel execution).

If you, for example, use an operation like

List<…> result=inputList.parallelStream().map(…).filter(…).collect(Collectors.toList());

the entire operation might benefit from parallel execution but the resulting list will always be in the right order, regardless of whether you use a parallel or sequential stream.

More Related Contents:

  1. Is there a concise way to iterate over a stream with indices in Java 8?
  2. Should I always use a parallel stream when possible?
  3. What’s the difference between map() and flatMap() methods in Java 8?
  4. Java 8 lambdas, Function.identity() or t->t
  5. Ignore duplicates when producing map using streams
  6. Can you split a stream into two streams?
  7. Why does parallel stream with lambda in static initializer cause a deadlock?
  8. Adding up BigDecimals using Streams
  9. Java 8 Streams FlatMap method example
  10. Parallel streams, collectors and thread safety
  11. Java 8, Streams to find the duplicate elements
  12. Fetch first element of stream matching the criteria
  13. forEach vs forEachOrdered in Java 8 Stream
  14. Why is Files.lines (and similar Streams) not automatically closed?
  15. Java 8 Stream with batch processing
  16. How to use a Java8 lambda to sort a stream in reverse order?
  17. Stream.skip behavior with unordered terminal operation
  18. Using streams to convert a list of objects into a string obtained from the toString method
  19. Java 8 Collectors.toMap SortedMap
  20. Why parallel stream get collected sequentially in Java 8
  21. In Stream reduce method, must the identity always be 0 for sum and 1 for multiplication?
  22. How to group objects when each object could go in multiple groups?
  23. Understanding deeply spliterator characteristics
  24. Why should I use concurrent characteristic in parallel stream with collect?
  25. How to add elements of a Java8 stream into an existing List
  26. How to implement a Java stream?
  27. Why didn’t Stream have a toList() method?
  28. Using Java8 Stream to find the highest values from map
  29. Nested Java 8 parallel forEach loop perform poor. Is this behavior expected?
  30. Parallel flatMap always sequential

Leave a Comment