一. 序

单例模式是我们在日常编程中，比较常用的设计模式。一个好的单例，必然需要满足唯一性和线程安全性。而 Java 中，关于单例的文章讲解已经很完善了，单例模式已经成为一种编程范式。

在谷歌强推 Kotlin 的今天，不少人使用 Kotlin 时，还带着 Java 的编程思维，并没有有效的利用 Kotlin 的一些特性。如果还用 Java 的编程思想来写 Kotlin 的单例，会有种四不像的感觉。

在 Kotlin 里，想要实现单例模式，只需要将类增加 object 关键字即可，这就是一个线程安全的单例模式，很方便。

但是这存在一个问题，object class 无法实现构造方法，也就是我们无法在初始化的时候，从外部传递一些参数来让这个单例类初始化。

本文就来聊聊 Kotlin 下的单例模式的实现，以及如何优雅的构造一个带参数的单例模式。

二. Kotlin 的单例

2.1 object class 的单例

虽然无法在构造的时候，从外部传递参数，但是 object 关键字依然是 Kotlin 下，最常用的构造单例方法，我们先来了解它的特性。

object 关键字使用起来非常简单，只需要直接作用在 class 上就好。

object SomeSingleton{
  fun sayHi(){}
}

这就是在 Kotlin 下，最简单的单例模式，如果想要有一些初始化的动作，可以放在 init 块中。

object SomeSingleton{
  init{
      // init
  }
  fun sayHi(){}
}

使用方法也非常简单，需要注意的是，在 Kotlin 中调用和 Java 调用存在一些差异。

// Kotlin Language
SomeSingleton.sayHi()

// Java  Language
SomeSingleton.INSTANCE.sayHi()

我们知道，Kotlin 和 Java 是可以无缝互通的，而 Kotlin 最终编译的字节码，其实也是可以转成类 Java 的代码。

那我们继续看看 Kotlin 的 object 关键字后，在 Java 中的表现到底如何。通过这种转码的分析，可以便于我们理解 Kotlin 的特性。

借助 AS 的 Tools → Kotlin → Show Kotlin Bytecode，就可以查看 Kotlin 文件的字节码，再点击 Decompile 按钮，就可以将字节码转成 Java 代码。

有对比就清晰了，Kotlin 的 object 关键字，在 Java 表现的特点如下：

类用 final 标记，标识不可变性。
内部声明一个 static final 的当前类的对象 INSATNCE。
在静态代码块中，进行 INSTANCE 对象的初始化。

可以看到，在 Kotlin 的 object 中，是使用类的初始化锁来保证线程安全的。

那什么是类的初始化锁？

简单来说， JVM 在类的初始化阶段（即在 Class 被加载后，且被线程使用之前），会执行类的初始化，在初始化期间，JVM 会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化，避免多线程调用时，引发线程安全的问题。

上图很清晰的表明了类的初始化锁的工作流程。

而 Kotlin 中的 object 关键字，就是利用类的初始化锁来保证线程安全的，在我们不需要为单例的初始化传递外部参数的场景下，可以放心使用。

那可能有人担心另一个问题，类加载的时候就初始化构造单例对象，是不是对资源的利用不友好？

这一点问题不大，虚拟机在运行程序的时候，并不是在启动时就将所有的类，都加载进来并初始化完成，而是一种按需加载的策略，在真正使用它的时候，才会初始化。

例如：new Class、调用静态方法、反射、调用 Class.forName() 方法等。这一点可以通过本文介绍的单例实现，在 init 块中输出 Log，看看 Log 何时输出来验证，相关资料很多，就不多说了。

也就是说，通常只有在你真实使用这个类时，它才会真的被虚拟机初始化。当然，不同虚拟机的实现方式不同，这并不是强制的，但是大多数为了性能都会准守此规则。

2.2 传参数的单例

无参单例可以用 object 关键字，但如果想通过一些外部参数初始化单例呢？Kotlin 的 object 是不能有任何构造函数的，所以也无法传递任何参数。

带参单例在 Android 中也是有一些使用场景的，例如 Android 中的 LocalBroadcastManager，就是一个带参的单例模式。

LocalBroadcastManager.getInstance（context）.sendBroadcast（intent）

那换个思路想想，在 Java 中，带参数的单例如何实现？通常都会用双重检查锁（Double Checked Locking） + volatile 关键字来解决。

public class DoubleCheckSingleton {
    private volatile static DoubleCheckSingleton sInstance;
    private DoubleCheckSingleton(Context ctx) {
          // init
    }
    public static DoubleCheckSingleton getInstance(Context ctx) {
        if (sInstance == null) {
            synchronized (DoubleCheckSingleton.class) {
                if (sInstance == null) {
                    sInstance = new DoubleCheckSingleton(ctx);
                }
            }
        }
        return sInstance;
    }
}

加上 volatile 是为了可见性和禁止重排序，这样就可以保证把参数传递进去的同时，确保线程安全。

不过在 Kotlin 中是没有 volatile 关键字的，取而代之的是 @Volatile 注解，同时需要配合 Kotlin 的伴生对象进行单例模式的构建。

伴生对象可以简单的使用类名作为限定符来调用其方法，类似 Java 中的静态方法。

final class SomeSingleton(context: Context) {
    private val mContext: Context = context
    companion object {
        @Volatile
        private var instance: SomeSingleton? = null
        fun getInstance(context: Context): SomeSingleton {
            val i = instance
            if (i != null) {
                return i
            }

            return synchronized(this) {
                val i2 = instance
                if (i2 != null) {
                    i2
                } else {
                    val created = SomeSingleton(context)
                    instance = created
                    created
                }
            }
        }
    }
}

这段代码是直接借鉴的 Kotlin 的 lazy()，lazy 在默认情况下的实现是 SynchronizedLazyImpl，从类名上就能看出来，它使用 synchroinzed 来保证线程安全。

用这样的方式，就可以实现一个可以传参数去构造的单例模式。

2.3 封装一个带参单例

支持传参的单例，我们实现了。但为了实现这个单例，写了 20+ 行代码。每次写单例都要把这一堆代码复制一遍，还挺麻烦，为了使用方便，还可以将其再封装一下。

open class SingletonHolder<out T, in A>(creator: (A) -> T) {
    private var creator: ((A) -> T)? = creator
    @Volatile
    private var instance: T? = null

    fun getInstance(arg: A): T {
        val i = instance
        if (i != null) {
            return i
        }

        return synchronized(this) {
            val i2 = instance
            if (i2 != null) {
                i2
            } else {
                val created = creator!!(arg)
                instance = created
                creator = null
                created
            }
        }
    }
}

用一个支持继承的 open class 加上泛型就可以简单的将其进行封装，此封装方式支持一个参数的构造方法，有需要可以继续扩展或者封装。

class SomeSingleton private constructor(context: Context) {
    init {
        // Init using context argument
        context.getString(R.string.app_name)
    }

    companion object : SingletonHolder<SomeSingleton, Context>(::SomeSingleton)
}

封装成 SingletonHolder 类之后，再想使用单例，关键代码一行就搞定了。

2.4 使用 lazy

前面在介绍带参单例的时候，也提到了lazy()，它是 Kotlin 的一种标准委托，可以接受一个 lambda 并返回一个实例的函数。

如果我们想要延迟初始化，可以使用 lazy() 这个代理来实现，它会在第一次调用get() 方法时，执行 lazy() 的 lambda 表达式并记录结果，之后再调用 get()就只会返回之前记录的结果，非常适合延迟初始化的场景。

class SomeSingleton{
    companion object {
        val instance: SomeSingleton by lazy { SomeSingleton() }
    }
}

lazy() 默认情况下，内部就是依赖同步锁（synchronized）来实现的，所以它也是线程安全的。

但是正如我前面提到的，类本身也是按需加载的，调用它的下一步肯定是也需要使用它，所以只要我们正确的使用单例模式，其实没必要使用 lazy()，这里仅做一个介绍，大家知道一下就好了。

三. 小结时刻

本文介绍了在 Kotlin 下，实现单例模式的一些代码技巧，希望对大家有所帮助。最后再简单总结一下。

无参单例模式，直接使用 Kotlin 的 object 即可，它是依赖类的初始化锁来保证线程安全。
带参单例模式，可以使用双重检查锁 + @Volatile 来实现，如果嫌麻烦还可以封装成 SingletonHolder。
lazy() 委托确实可以实现延迟加载，但是在单例模式的场景下，不如直接用object 方便。