performance - 这是 Scala 2.9.1 延迟实现中的错误还是只是反编译的产物

Question

我正在考虑在一个计算量相当大的程序上使用 Scala。对代码的 C++ 版本进行分析表明，我们可以从惰性求值中获益匪浅。我在 Scala 2.9.1 中尝试过并且非常喜欢它。然而，当我通过反编译器运行该类时，实现看起来不太正确。我假设它是反编译器的产物，但我想得到更结论性的答案......

考虑以下简单示例:

class TrivialAngle(radians : Double) 
{
    lazy val sin = math.sin(radians)
}

当我反编译它时，我得到这个:

import scala.ScalaObject;
import scala.math.package.;
import scala.reflect.ScalaSignature;

@ScalaSignature(bytes="omitted")
public class TrivialAngle
  implements ScalaObject
{
  private final double radians;
  private double sin;
  public volatile int bitmap$0;

  public double sin()
  {
    if ((this.bitmap$0 & 0x1) == 0);
    synchronized (this)
    {
      if (
        (this.bitmap$0 & 0x1) == 0)
      {
        this.sin = package..MODULE$.sin(this.radians);
        this.bitmap$0 |= 1; 
      } 
      return this.sin;
    }
  }

  public TrivialAngle(double radians)
  {
  }
}

对我来说，返回 block 位于错误的位置，并且您将始终获得锁。这不可能是真正的代码正在做的事情，但我无法确认这一点。谁能确认或否认我有一个虚假的反编译，并且惰性实现在某种程度上是合理的(即仅在计算值时锁定，并且在后续调用时不获取锁定？)

谢谢!

作为引用，这是我使用的反编译器: http://java.decompiler.free.fr/?q=jdgui

Answer 1

scala -Xprint:jvm 揭示了真实的故事:

[[syntax trees at end of jvm]]// Scala source: lazy.scala
package <empty> {
  class TrivialAngle extends java.lang.Object with ScalaObject {
    @volatile protected var bitmap$0: Int = 0;
    <paramaccessor> private[this] val radians: Double = _;
    lazy private[this] var sin: Double = _;
    <stable> <accessor> lazy def sin(): Double = {
      if (TrivialAngle.this.bitmap$0.&(1).==(0))
        {
          TrivialAngle.this.synchronized({
            if (TrivialAngle.this.bitmap$0.&(1).==(0))
              {
                TrivialAngle.this.sin = scala.math.`package`.sin(TrivialAngle.this.radians);
                TrivialAngle.this.bitmap$0 = TrivialAngle.this.bitmap$0.|(1);
                ()
              };
            scala.runtime.BoxedUnit.UNIT
          });
          ()
        };
      TrivialAngle.this.sin
    };
    def this(radians: Double): TrivialAngle = {
      TrivialAngle.this.radians = radians;
      TrivialAngle.super.this();
      ()
    }
  }
}

这是一个(自 JVM 1.5 起)安全且非常快速的双重检查锁。

更多详细信息:

What's the (hidden) cost of Scala's lazy val?

请注意，如果类中有多个惰性 val 成员，则一次只能初始化其中一个，因为它们由 synchronized(this) { ... } 保护。