18

Is it possible that a parallel stream could give a different result than a serial stream in Java 8? According to my information, a parallel stream is the same as a serial stream except divided into multiple substreams. It is a question of speed. All operations over the elements are done and the results of the substreams are combined at the end. In the end, the result of the operations should be the same for parallel and serial streams in my opinion. So my question is, is it possible that this code could give me a different result? And if it is possible, why does it happen?

int[] i = {1, 2, 5, 10, 9, 7, 25, 24, 26, 34, 21, 23, 23, 25, 27, 852, 654, 25, 58};
Double serial = Arrays.stream(i).filter(si -> {
    return si > 5;
}).mapToDouble(Double::new).map(NewClass::add).reduce(Math::atan2).getAsDouble();

Double parallel = Arrays.stream(i).filter(si -> {
    return si > 5;
}).parallel().mapToDouble(Double::new).map(NewClass::add).reduce(Math::atan2).getAsDouble();

System.out.println("serial: " + serial);
System.out.println("parallel: " + parallel);

public static double add(double i) {
    return i + 0.005;
}

and results are:

serial: 3.6971567726175894E-23

parallel: 0.779264049587662
Improve this question
8
  • 6
    Reducing using atan2 makes no sense at all. It is not associative for example. Commented Sep 26, 2015 at 17:36
  • 1
    FYI: si -> { return si > 5; } should be just si -> si > 5, and you'd want to do the filter after the parallel(). Commented Sep 26, 2015 at 17:38
  • 2
    No, the problem is that reduce requires an associative function Commented Sep 26, 2015 at 17:57
  • 3
    @Andreas, you may place .parallel() anywhere between stream start and terminal operation, the result will be the same. Commented Sep 27, 2015 at 7:46
  • 2
    The call .mapToDouble(Double::new) is widening each int to double, boxing them into Double objects, just to unbox them afterwards to double value. If you want to convert int to double, a .mapToDouble(i->i) would be much more straightforward, skipping the object creation. But even simpler is .asDoubleStream()… And, if you really need boxed values, use Double::valueOf instead of Double::new. Commented Sep 28, 2015 at 8:11

3 Answers 3

Reset to default
13

The javadoc for reduce() says:

Performs a reduction on the elements of this stream, using an associative accumulation function, [...] The accumulator function must be an associative function.

The word "associative" is linked to this java doc:

An operator or function op is associative if the following holds:

 (a op b) op c == a op (b op c)

The importance of this to parallel evaluation can be seen if we expand this to four terms:

 a op b op c op d == (a op b) op (c op d)

So we can evaluate (a op b) in parallel with (c op d), and then invoke op on the results.

Examples of associative operations include numeric addition, min, and max, and string concatenation.

As @PaulBoddington mentioned in a comment, atan2 is not associative, and is therefore not valid for a reduction operation.

Unrelated

Your stream sequence is a bit off. You should filter after the parallel operation, the lambda can be shortened, and you shouldn't box the double:

double parallel = Arrays.stream(i)
                        .parallel()           // <-- before filter
                        .filter(si -> si > 5) // <-- shorter
                        .asDoubleStream()     // <-- not boxing
                        .reduce(Math::atan2)
                        .getAsDouble();
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Unrelated part is completely unrelated. The .parallel() may be located in any place of your pipeline and the result will be the same.
@TagirValeev - Will it not run quicker if you parallel it earlier?
@ArtOfWarfare, no, it won't.
4

When you use reduce with a parallel stream, the operations are not done in a specific order.

Therefore if you want parallel streams to produce a predictable result, your reduce operation must have the same answer no matter what order things are done in.

For example, reducing using addition makes sense, because addition is associative. It doesn't matter which of these you do, the answer is 6 in both cases.

(1 + 2) + 3
1 + (2 + 3)

atan2 is not associative.

Math.atan2(Math.atan2(1, 2), 3) == 0.15333604941031637

whereas

Math.atan2(1, Math.atan2(2, 3)) == 1.0392451500584097
Improve this answer

Comments

3

Your reduce method produces different results, if the elements are given in a different orders.

So if you use a parallel stream the original order is not garanteed.

If you use a different reduction method (e.g. (x,y) -> x+y) it works just fine.

Improve this answer

4 Comments

Order is always the same. The way the results are combined is different. Order-independent operation is commutative. Combination-independent operation is associative. Here order is kept, so the commutativity is unnecessary.
@TagirValeev, that only applies to ordered streams.
@the8472, surely unordered stream is unordered.
Yes, but in the absence of ordering serial and parallel streams may behave differently, which may not be relevant to OP's particular example but it does apply to the question in general.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.