這是Scala 2.9.1中的一個bug懶惰的實現還是隻是一個反編譯的工件

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) 
    { 
    } 
} 

對我而言，返回塊位於錯誤的位置，並且您將始終獲取鎖定。這不可能是真正的代碼在做什麼，但我無法證實這一點。任何人都可以確認或否認我有一個虛假的反編譯，並且這個懶惰的實現是有點合理的（即，只有當它計算值時鎖定，並且不會獲得後續調用的鎖定）。

謝謝！

供參考，這是我使用的反編譯： 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) { ... }把守。

Answer 2

什麼我得到javap -c不符合您的反編譯。特別是當發現字段被初始化時，沒有監視器輸入。版本2.9.1也是如此。當然，仍然存在着易失性訪問所暗示的內存障礙，所以它不會完全免費。開始///評論是我

public double sin(); 
    Code: 
    0: aload_0 
    1: getfield  #14; //Field bitmap$0:I 
    4: iconst_1 
    5: iand 
    6: iconst_0 
    7: if_icmpne  54 /// if getField & 1 == O goto 54, skip lock 
    10: aload_0 
    11: dup 
    12: astore_1 
    13: monitorenter 
      /// 14 to 52 reasonably equivalent to synchronized block 
      /// in your decompiled code, without the return 
    53: monitorexit 
    54: aload_0 
    55: getfield  #27; //Field sin:D 
    58: dreturn  /// return outside lock 
    59: aload_1  /// (this would be the finally implied by the lock) 
    60: monitorexit 
    61: athrow 
    Exception table: 
    from to target type 
    14 54 59 any