主页 / 问题 / 625153
Accepted
TimurVI
Asked:2020-02-08 21:37:01 +0000 UTC2020-02-08 21:37:01 +0000 UTC

在 lambda 表达式中捕获值

  • 772

Lambda 表达式应该用于捕获值，而不是变量。捕获值会鼓励您编写没有副作用的代码，因为替代方案更难。

在lambda表达式中捕获值是什么意思？

java

2 个回答

  1. 大概，作者的意思是lambda表达式不应该接触变量，而是将一个值作为输入，在输出处赋值。例如：

    很糟糕：

    final String string = "string";
class.method(() -> string += "abc");

    好的：

    class.method((string) -> string += "abc");
    • 8
  2. Best Answer

    这意味着你应该在 lambda 表达式中使用外部（相对于表达式）不可变的值，而不是值和内部状态可以改变的外部变量。外部不可变值分别意味着有效的最终局部变量和原始类型的字段，以及有效的内部状态不会改变的最终对象。

    这是因为 Streams 和 lambda 表达式被设计为多线程的。

    使用变量 ( counter) 而不是值的问题在此示例中可见：

    private static class Element
{
    private final int value;

    public Element(int value) { this.value = value; }

    public int getValue() { return value; }
}

private static volatile int counter = 0;

public static void main(String[] args)
{
    List<Element> list = new ArrayList<>();
    for (int i = 0; i < 100 * 1000; i++)
    {
        list.add(new Element(1));
    }
    list.parallelStream().forEach(e -> counter += e.getValue());
    System.out.println(counter);
}

    不必指望值会显示在屏幕上100000，因为存在竞争条件。在我的测试中，这段代码在 100,000 次中只能得到 299 次正确值。

    这就是为什么在 lambda 表达式中使用的局部变量必须是有效最终变量的原因之一。代码有效性

    int localCounter = 0;
list.parallelStream().forEach(e -> localCounter += e.getValue());

    会导致局部变量的竞争条件，这将是Java多线程编程的新一轮问题。局部变量被认为是线程安全的，Java 开发人员不想打破这一原则。

    您可以像这样欺骗编译器来限制有效的最终值：

    int[] localCounter = { 0 };
list.parallelStream().forEach(e -> localCounter[0] += e.getValue());
System.out.println(localCounter[0]);

    因此，在使用有效的 final 局部变量时，仍有可能“搬起石头砸自己的脚”。当然，您不应该对该值再次计算错误感到惊讶。实际上，这绝对不是要走的路。

    是的，你可以在这里使用AtomicInteger：

    AtomicInteger atomicInteger = new AtomicInteger();
list.parallelStream().forEach(e -> atomicInteger.addAndGet(e.getValue()));
System.out.println(atomicInteger.get());

    然而，这扼杀了代码并行化的整个思想。

    在这种情况下，假定使用一堆mapand reduce：

    int localCounter = list.parallelStream().map(e -> e.getValue()).reduce(0, (a, b) -> a + b);
System.out.println(localCounter);

    map有和的部分reduce也可以这样写：

    .map(Element::getValue).reduce(0, Integer::sum)

    可以在此处阅读 Brian Goetz（《Java 并发实践》的作者）关于此的文章。

    然而，捕获变量而不是值的问题不仅仅发生在并行执行中。例如：

    private static class Element
{
    public int x;

    public Element(int x) { this.x = x; }

    public Function<Integer, Integer> getMapper()
    {
        return (e -> e + x);
    }
}

public static void main(String[] args)
{
    Element element = new Element(2);
    List<Integer> list1 = Arrays.asList(10, 20, 30);
    Function<Integer, Integer> function1 = element.getMapper();
    element.x = 4;
    List<Integer> list2 = Arrays.asList(10, 20, 30);
    Function<Integer, Integer> function2 = element.getMapper();
    list1 = list1.stream().map(function1).collect(Collectors.toList());
    list2 = list2.stream().map(function2).collect(Collectors.toList());
    System.out.println(list1);
    System.out.println(list2);
}

    在此代码中，捕获了一个变量（不是有效的最终字段）x，因此，而不是预期的输出

    [12, 22, 32]
[14, 24, 34]

    将被显示

    [14, 24, 34]
[14, 24, 34]

    捕获相同值时：

    public Function<Integer, Integer> getMapper()
{
    int n = x;
    return (e -> e + n);
}

    不会有这样的问题/错误。

    • 8

相关问题