Java Collector.combiner getting called with supplier values always - java-8

Question

Problem : Create a Collector implementation which would multiply stream of Integers in parallel and return Long.
Implementation:
public class ParallelMultiplier implements Collector<Integer, Long, Long> {
#Override
public BiConsumer<Long, Integer> accumulator() {
// TODO Auto-generated method stub
return (operand1, operand2) -> {
System.out.println("Accumulating Values (Accumulator, Element): (" + operand1 + ", " + operand2 + ")");
long Lval = operand1.longValue();
int Ival = operand2.intValue();
Lval *= Ival;
operand1 = Long.valueOf(Lval);
System.out.println("Acc Updated : " + operand1);
};
}
#Override
public Set<java.util.stream.Collector.Characteristics> characteristics() {
// TODO Auto-generated method stub
return Collections.unmodifiableSet(EnumSet.of(UNORDERED));
}
#Override
public BinaryOperator<Long> combiner() {
return (operand1, operand2) -> {
System.out.println("Combining Values : (" + operand1 + ", " + operand2 + ")");
long Lval1 = operand1.longValue();
long Lval2 = operand2.longValue();
Lval1 *= Lval2;
return Long.valueOf(Lval1);
};
}
#Override
public Function<Long, Long> finisher() {
// TODO Auto-generated method stub
return Function.identity();
}
#Override
public Supplier<Long> supplier() {
return () -> new Long(1L);
}
}
Observed Output:
Accumulating Values (Accumulator, Element): (1, 4)
Acc Updated : 4
Accumulating Values (Accumulator, Element): (1, 3)
Acc Updated : 3
Combining Values : (1, 1)
Accumulating Values (Accumulator, Element): (1, 8)
Accumulating Values (Accumulator, Element): (1, 6)
Accumulating Values (Accumulator, Element): (1, 2)
Acc Updated : 2
Acc Updated : 8
Accumulating Values (Accumulator, Element): (1, 5)
Accumulating Values (Accumulator, Element): (1, 1)
Acc Updated : 5
Acc Updated : 6
Combining Values : (1, 1)
Accumulating Values (Accumulator, Element): (1, 7)
Acc Updated : 7
Combining Values : (1, 1)
Combining Values : (1, 1)
Acc Updated : 1
Combining Values : (1, 1)
Combining Values : (1, 1)
Combining Values : (1, 1)
Invocation:
List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
Collector<Integer, Long, Long> parallelMultiplier = new ParallelMultiplier();
result = intList.parallelStream().collect(parallelMultiplier);
i.e. multiplication result is 1, where it should have been 8 factorial. I am not using 'concurrent' Characteristics either.
Ideally, i should have gotten multiplication result of substreams, fed into combiner() operation, but that seems to be not happening here.
Keeping aside the inefficient implementations of boxing/unboxing, any clue where I might have made mistake??

Answer 1

Your collector is slightly off. Here is a simplified version(the why your does not work - see at the end):
static class ParallelMultiplier implements Collector<Integer, long[], Long> {
#Override
public BiConsumer<long[], Integer> accumulator() {
return (left, right) -> left[0] *= right;
}
#Override
public BinaryOperator<long[]> combiner() {
return (left, right) -> {
left[0] = left[0] * right[0];
return left;
};
}
#Override
public Function<long[], Long> finisher() {
return arr -> arr[0];
}
#Override
public Supplier<long[]> supplier() {
return () -> new long[] { 1L };
}
#Override
public Set<java.util.stream.Collector.Characteristics> characteristics() {
return Collections.unmodifiableSet(EnumSet.noneOf(Characteristics.class));
}
}
You problems can be exemplified like this:
static Long test(Long left, Long right) {
left = left * right;
return left;
}
long l = 12L;
long r = 13L;
test(l, r);
System.out.println(l); // still 12

Answer 2

As Flown stated, Java's primitive wrapper types are immutable and cannot be used as an accumulator. Because you're computing the multiplication in parallel, we'll want to use a thread-safe implementation of a mutable Long, which is an AtomicLong.
import java.util.*;
import java.util.concurrent.atomic.*;
import java.util.function.*;
import java.util.stream.*;
public class ParallelMultiplier implements Collector<Integer, AtomicLong, Long> {
#Override
public BiConsumer<AtomicLong, Integer> accumulator() {
return (operand1, operand2) -> operand1.set(operand1.longValue() * operand2.longValue());
}
#Override
public Set<java.util.stream.Collector.Characteristics> characteristics() {
return Collections.unmodifiableSet(EnumSet.of(Characteristics.UNORDERED));
}
#Override
public BinaryOperator<AtomicLong> combiner() {
return (operand1, operand2) -> new AtomicLong(operand1.longValue() * operand2.longValue());
}
#Override
public Function<AtomicLong, Long> finisher() {
return l -> l.longValue();
}
#Override
public Supplier<AtomicLong> supplier() {
return () -> new AtomicLong(1);
}
}
Testing this with what you've provided results in the correct answer, 8! = 40320.