Scala基礎應用（11）- 懶加載(lazy語法糖)

Scala基礎應用（11）- 懶加載(lazy語法糖)

Scala中使用lazy關鍵字來標識變量是否是懶加載

• 所謂懶加載, 就是在聲明時並不會直接執行，只有在使用該變量的時候，該變量所對應的賦值語句纔會被執行

在Java中的實現方式 (內部類或Singleton)

• 內部類

  public class LazyLoadClass {
      private LazyLoadClass() {        
      }
  
      public static LazyLoadClass getInstance() {
          return LazyLoadClassHolder;
      }
  
      private static class LazyLoadClassHolder {
          private static final LazyLoadClass instance = new LazyLoadClass();
      }
  }

  使用：

  LazyLoadClass lazyLoad = LazyLoadClass.getInstance()

• 單例

  public static class SingletonLazyClass {
  　　　　static SingletonLazyClass instance = null;
  　　　　public static SingletonLazyClass getInstance() {
  　　　　　　if (instance == null) {
  　　　　　　　　createInstance();
  　　　　　　}
  　　　　　　return instance;
  　　　　}
  　　　　private synchronized static SingletonLazyClass createInstance() {
  　　　　　　if (instance == null) {
  　　　　　　　　instance = new SingletonLazyClass();
  　　　　　　}
  　　　　　　return instance;
  　　　　}
  }

C#中的實現

class LazyLoadClass {
private Lazy<String> str = new Lazy<string> (() => getStr ());

private String getStr() {
    return "this is a string"
}

public String Str
{
  get
  {
      return str.Value;
  }
}

Scala中的實現

通過Java或C#的實現，我們基本瞭解，先聲明，然後在使用時才賦值，並且只有一個實例，從而達到懶加載的目的。

那麼在Scala中如何實現的呢？

• 首先我們先看一下不使用懶加載的例子

  object LazyLoadClass {
      def getStr(): String = {
          println("call getStr()")
          return ""
      }
      def main(args: Array[String]) {
          val str = getStr();      // 沒有使用lazy修飾
          println("after getStr()")
          println(property)
      }
  }

  打印結果爲：

  call getStr()
  after getStr()

• 如果我們給變量str加上懶加載

  object LazyLoadClass {
      def getStr(): String = {
          println("call getStr()")
          return ""
      }
      def main(args: Array[String]) {
          lazy val str = getStr();      // 使用lazy修飾
          println("after getStr()")
          println(str)
      }
  }

  打印結果爲：

  after getStr()
  call getStr()

• 通過反編譯我們可以看到，它的實現方式與Java和C#沒什麼區別:

  lazy val str = getStr() 會被展開爲如下實現:

  private String str;
  private volatile boolean bitmap$0;
  
  private String str$lzycompute()
  {
    synchronized (this) {
      if (!this.bitmap$0) {
          this.str = getStr();
          this.bitmap$0 = true;
      }
  
      return this.str;
    }
  }
  
  public String str() {
    return this.bitmap$0 ? this.str : str$lzycompute();
  }