collect中的accumulator和combiner有什么区别？ [复制]

Question

为什么并行流使用组合器类，而顺序流使用累加器？为什么并行流不使用累加器？

package Streams;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class Collect
{
    public static class Debug
    {
        public static void log(Object ... objects)
        {
            for(Object object : objects) {
                System.out.println(object);
            }
        }
    }

    public static void main(String[] args)
    {
        parallel();
        Debug.log("---------------");
        sequential();
    }

    public static void parallel()
    {
        List<Integer> list = Stream.of(1,2,3,4)
                .parallel()
                .collect(
                        ArrayList::new,
                        (a,b)-> {
                            Debug.log("From accumulator",a,b);
                            a.add(b);
                        },
                        (a,b) -> {
                            Debug.log("From combiner",a,b);
                            a.addAll(b);
                        }
                );
    }

    public static void sequential()
    {
        List<Integer> list = Stream.of(1,2,3,4)
                .collect(
                        ArrayList::new,
                        (a,b)-> {
                            Debug.log("From accumulator",a,b);
                            a.add(b);
                        },
                        (a,b) -> {
                            Debug.log("From combiner",a,b);
                            a.addAll(b);
                        }
                );
    }
}

这是上面代码的输出：

From accumulator
[]
From accumulator
From accumulator
From accumulator
[]
[]
1
4
3
[]
2
From combiner
From combiner
[3]
[1]
[4]
[2]
From combiner
[1, 2]
[3, 4]
---------------
From accumulator
[]
1
From accumulator
[1]
2
From accumulator
[1, 2]
3
From accumulator
[1, 2, 3]
4

那么，为什么顺序流使用累加器而并行流使用组合器？并行流不能使用累加器吗？

Answer 1

组合器的工作似乎是组合为每个线程创建的不同List-objects（与parallel）。

    public static void parallel()
    {
        List<Integer> list = Stream.of(1,2,3,4)
                .parallel()
                .collect(
                        ArrayList::new,
                        (a,b)-> {
                            Debug.log("From accumulator",a,b);
                            a.add(b);
                        },
                        (a,b) -> {
                            Debug.log("From combiner",a,b);
                            a.addAll(b);
                        }
                );
    }

所以在上面的示例中，对于 1、2、3、4，为每个元素创建了一个新的 ArrayList，因为它们在不同的线程上并行运行。所以combiner将现有的4个ArrayLists合二为一。