<p>现在 Kotlin 的趋势日益高涨，Jake Wharton 大神近期从 Square 公司离职到 Google 负责 Kotlin 部分。我最近分析了 Kotlin 下的单例模式的实现方式，与 Java 下的实现有点区别，之前写过一篇 <a href="/misc/goto?guid=4959751576141834346" rel="nofollow,noindex">Java 设计模式之单例模式</a> 。</p>    <h2>饿汉式</h2>    <p>Kotlin 引入了 object 类型，可以很容易声明单例模式。</p>    <pre>  <code class="language-kotlin">object Singleton {      ...  }    // Kotlin 中调用  Singleton.xx()    // Java 中调用  Singleton.INSTANCE.xx()  </code></pre>    <p>这种方式和 Java 单例模式的饿汉式一样，不过比 Java 中的实现代码量少很多，其实是个语法糖。反编译生成的 class 文件后如下：</p>    <pre>  <code class="language-kotlin">public final class Singleton{      public static final Singleton INSTANCE = null;        static {          Singleton singleton = new Singleton();      }        private Singleton(){          INSTANCE = this;      }  }  </code></pre>    <p>从反编译的代码可以看出 object 对象实际上还是利用了 INSTANCE 静态变量，所以在 Java 中调用时需要使用 Singleton.INSTANCE.xx() 。</p>    <p>这种实现方式在类加载时就创建了单例对象，所以肯定是线程安全的，但是还是有饿汉式实现方式的问题：</p>    <ul>     <li> <p>如果构造方法中有耗时操作的话，会导致这个类的加载比较慢。</p> </li>     <li> <p>饿汉式一开始就创建实例，但是并没有调用，会造成资源浪费。</p> </li>     <li> <p>还有一个 Java 饿汉式单例模式没有的问题：无法自定义构造函数，object 中不允许 constructor 函数。</p> </li>    </ul>    <h2>懒汉式</h2>    <p>前面的 object 的实现方式是饿汉式的，开始使用前就实例化好了，如何在第一次调用时在初始化呢？Kotlin 中的延迟属性 Lazy 刚好适合这种场景。</p>    <pre>  <code class="language-kotlin">class Singletonprivate constructor() {      companion object {          val instance: Singleton by lazy { Singleton() }      }  }    // Kotlin 中调用  Singleton.instance.xx()    // Java 中调用  Singleton.Companion.getInstance().xx()  </code></pre>    <p>Lazy 延迟属性默认是线程安全的，它具体是如何实现的呢？Java 中线程安全的懒汉式有 synchronized 修饰方法、双重检查锁定、静态内部类，更多内容请阅读 <a href="/misc/goto?guid=4959751576141834346" rel="nofollow,noindex">Java 设计模式之单例模式</a> ，下面看 Lazy 属性的源码：</p>    <pre>  <code class="language-kotlin">public fun <T>lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)    private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {      private var initializer: (() -> T)? = initializer      @Volatile private var _value: Any? = UNINITIALIZED_VALUE    // 声明为 volatile 变量      // final field is required to enable safe publication of constructed instance      private val lock = lock ?: this        override val value: T          get() {              val _v1 = _value              if (_v1 !== UNINITIALIZED_VALUE) {  // 第一次检查                  @Suppress("UNCHECKED_CAST")                  return _v1 as T              }                return synchronized(lock) {  // 加锁锁定                  val _v2 = _value                  if (_v2 !== UNINITIALIZED_VALUE) {  // 第二次检查                      @Suppress("UNCHECKED_CAST") (_v2 as T)                  }                  else {                      val typedValue = initializer!!()                      _value = typedValue                      initializer = null                      typedValue                  }              }          }        ...  }  </code></pre>    <p>从上面代码中可以看出延迟属性 Lazy 内部也是使用双重检查锁定来实现线程安全的延迟初始化的。</p>    <p>LazyThreadSafetyMode</p>    <p>延迟属性 Lazy 默认线程安全模式是 LazyThreadSafetyMode.SYNCHRONIZED，使用同步锁的，LazyThreadSafetyMode 共有三种模式：</p>    <ul>     <li> <p>SYNCHRONIZED – 使用同步锁保证只有一个线程可以初始化实例。</p> </li>     <li> <p>PUBLICATION – 同一时期多个线程可以初始化实例，但是只有最先返回的值会作为延迟初始化的实例，使用 AtomicReferenceFieldUpdater.compareAndSet() 方法实现。</p> </li>     <li> <p>NONE – 没有任何的线程安全的保证和开销。</p> </li>    </ul>    <p>例如， lazy (LazyThreadSafetyMode.PUBLICATION, { LazySingleton() }) 。</p>    <h2>小结</h2>    <p>内存占用低时，可以选择 object 声明的饿汉式单例模式，简单有效；如果初始化时需要额外的操作或者实例资源消耗大时，推荐 Lazy 延迟属性的懒汉式单例模式。</p>    <p> </p>    <p>来自：http://johnnyshieh.me/posts/kotlin-singleton-pattern/</p>    <p> </p>