减少没有组合器的并行流由多个线程正确执行。在这种情况下，我应该什么时候使用组合器？

Question

我阅读了以下内容：

https://stackoverflow.com/a/22814174/2674303

我决定合并器只在并行流中使用，以获得正确的合并累加器结果。每个线程上有一个累加器实例。

因此，我作出决议，减少没有合路器将无法正常工作。

为了验证这一点，我编写了以下示例：

   Person reduce = Person.getPersons().stream()
                .parallel() 
                .reduce(new Person(), (intermediateResult, p2) -> {
                    System.out.println(Thread.currentThread().getName());
                    return new Person("default", intermediateResult.getAge() + p2.getAge());
                });
        System.out.println(reduce);

型号：

public class Person {

    String name;

    Integer age;
    ///...

    public static Collection<Person> getPersons() {
        List<Person> persons = new ArrayList<>();
        persons.add(new Person("Vasya", 12));
        persons.add(new Person("Petya", 32));
        persons.add(new Person("Serj", 10));
        persons.add(new Person("Onotole", 18));
        return persons;
   }
}

如您所见，我不提供组合器
示例输出：

ForkJoinPool.commonPool-worker-3
ForkJoinPool.commonPool-worker-2
ForkJoinPool.commonPool-worker-1
ForkJoinPool.commonPool-worker-2
ForkJoinPool.commonPool-worker-1
ForkJoinPool.commonPool-worker-1
Person{name='default', age=72}

我已经执行了几次应用程序，总是看到正确的结果。

请解释一下，如果不提供合并器，如何减少并行流的工作。

Answer 1

3-argumentreduce适用于以下不常见的情况：

想象一下，不是将人流减少为人流，而是使用不同的中间值，如PopulationStats。

class PopulationStats {
  // make new stats that includes this person
  PopulationStats addPerson(Person p) {
    return new PopulationStats(........);
  }

  // make new stats that combines this and other stats
  PopulationStats addStats(PopulationStats other) {
    return new PopulationStats(........);
  } 
}

在这种情况下，3参数减少用于避免在减少之前为每个Person制作PopulationStats的中间步骤。

PopulationStats stats = people.stream()
  .reduce(new PopulationStats(), PopulationStats::addPerson, PopulationStats::addStats);

Answer 2

您指定了一个组合器。在这种情况下，合并器函数与累加器函数相同。

如果结果类型与流元素类型相同，那么这总是可能的。

与通过求和值进行约简相比，a b c d可以通过计算（a b）（c d）并行计算。这里，累加器是加法，它与处理（a b）和（c d）中间结果的组合器函数的操作相同。

该示例还表明，除非涉及类型转换，否则如果需要不同的组合器函数，则会很奇怪，因为累加器函数的关联性约束意味着它通常足以作为组合器函数。请记住，流是否计算、a b c d、（a b c）d、（a b）（c d）或a（b c d）应该是无关的。

Answer 3

在这种情况下，累加器也可以作为合路器工作。当归约类型与流元素类型相同时，这是一种简写。因此

myStream.reduce(identity, accumulator);

完全等同于

myStream.reduce(identity, accumulator, accumulator);

您甚至可以在OpenJDK中查看这些方法的源代码：

@Override
public final <R> R reduce(R identity, BiFunction<R, ? super P_OUT, R> accumulator, 
                          BinaryOperator<R> combiner) {
    return evaluate(ReduceOps.makeRef(identity, accumulator, combiner));
}

@Override
public final P_OUT reduce(final P_OUT identity, final BinaryOperator<P_OUT> accumulator) {
    return evaluate(ReduceOps.makeRef(identity, accumulator, accumulator));
}

三参数版本更灵活，因为归约操作可能会生成另一种类型的对象。在这种情况下，您不能使用双参数归约，因为您没有提供如何组合结果类型的两个元素的规则。然而，当结果类型相同时，累加器和合并器处理相同的对象类型，因此如果它是关联的，则应该是相同的操作。