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();
  }