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