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