为什么共享可变性不好？

Question

我正在观看有关Java的演示，有一次讲师说：

“可变性还可以，共享很好，共享可变性是魔鬼的工作。”

他指的是以下代码，他认为这是“极度坏习惯”：

//double the even values and put that into a list.
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3, 4, 5);
List<Integer> doubleOfEven = new ArrayList<>();

numbers.stream()
       .filter(e -> e % 2 == 0)
       .map(e -> e * 2)
       .forEach(e -> doubleOfEven.add(e));

然后，他着手编写应使用的代码，即：

List<Integer> doubleOfEven2 =
      numbers.stream()
             .filter(e -> e % 2 == 0)
             .map(e -> e * 2)
             .collect(toList());

我不明白为什么第一段代码是“不良习惯”。对我来说，他们都实现了相同的目标。

Answer 1

当执行并行处理时，该问题就起作用了。

//double the even values and put that into a list.
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3, 4, 5);
List<Integer> doubleOfEven = new ArrayList<>();

numbers.stream()
       .filter(e -> e % 2 == 0)
       .map(e -> e * 2)
       .forEach(e -> doubleOfEven.add(e)); // <--- Unnecessary use of side-effects!

在使用流时，这不必要地使用了 副作用，
但如果正确使用，并非所有副作用都不好，因此必须提供一种可以安全地在输入的不同部分上同时执行的行为。例如，编写不访问共享的可变数据来执行其工作的代码。

该行：

.forEach(e -> doubleOfEven.add(e)); // Unnecessary use of side-effects!

不必要地使用了副作用，并且在并行执行时，的非线程安全性ArrayList将导致错误的结果。

前一段时间，我读了 Henrik Eichenhardt 的博客，回答
为什么共享的可变状态是万恶之源。

这是一个简短的推理，为什么共享的可变性是 不是 好; 从博客中提取。

非确定性=并行处理+可变状态

该方程式基本上意味着并行处理和可变状态组合都会导致 不确定的程序行为
。如果您仅执行并行处理并且仅具有不变状态，那么一切都很好，并且很容易推理出程序。另一方面，如果要对可变数据进行并行处理，则需要同步对可变变量的访问，这实际上使程序的这些部分变为单线程。这并不是真正的新事物，但是我还没有看到这个概念如此优雅地表达。
一个不确定的程序被破坏了 。

该博客继续得出内部细节，以解释为什么没有正确同步的并行程序被破坏，您可以在附加的链接中找到这些细节。

第二个示例代码段的说明

List<Integer> doubleOfEven2 =
      numbers.stream()
             .filter(e -> e % 2 == 0)
             .map(e -> e * 2)
             .collect(toList()); // No side-effects!

这会使用来对该流的元素使用 缩减 收集操作Collector。

这样更 安全 ，更 有效 并且更易于并行化。