Kotlin单例的几种写法

1. 饿汉式单例

---

Kotlin 语法层面就支持单例，即 object 关键字，相对于Java 单例的一坨模板代码简单得多：

object WorkSingleton

反编译后会发现，object实际是一个基于static的饿汉式的单例，有点是线程安全，缺点是不能实现懒加载：

public final class WorkSingleton {
   public static final WorkSingleton INSTANCE;

   static {
      WorkSingleton var0 = new WorkSingleton();
      INSTANCE = var0;
   }
}

2. 懒汉式单例

---

利用伴生对象 和 by lazy 也可以实现单例，可以实现懒汉式的线程安全单例

class WorkSingleton private constructor() {

    companion object {
        //LazyThreadSafetyMode.SYNCHRONIZED可以省略
        val INSTANCE1 by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) { WorkSingleton() }

    }
}

非多线程环境下，可以 mode = LazyThreadSafetyMode.NONE，就是一个非线程安全单例，以提高性能

3. 带参数单例

---

有时希望在单例初始化时传递参数，例如

Singleton.getInstance(context).doSome()

可以通过伴生对象的继承实现：

class WorkSingleton private constructor(context: Context) {
    init {
        // Init using context argument
    }

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


open class SingletonHolder<out T : Any, 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
            }
        }
    }
}

与Java 中双重校验锁的机制很像， SingletonHolder 类中如果已经初始化了直接返回，如果没有初始化进入 synchronized 代码块创建对象。

通过 Kotlin 将伴生对象作为子类实现了与静态继承相当的功能，所以我们将 SingletonHolder 作为单例类伴生对象的基类，便于在单例类上复用，凡是需要传递参数的单例模式，只需将单例类的伴生对象继承于 SingletonHolder，然后通过泛型指定单例类和参数类型即可：

class FileSingleton private constructor(path: String) {

    companion object : SingletonHolder<FileSingleton, String>(::FileSingleton)

}