Kotlin语言的单例实现方式

静态内部类实现方式

class Singleton private constructor() {
    companion object {
        val instance = SingletonInstance.instance
    }

    private object SingletonInstance {
        val instance = Singleton ()
    }
}

Kotlin语言的静态内部类单例的实现方式，没有什么好说的。几乎就是翻写Java的实现。

双重校验同步锁实现方式

class Singleton private constructor() {
    companion object {
    	//这里的mode 
        val instance: Singleton by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
        	Singleton () 
        }
    }
}

有没有发现，相对于Java的双重判断 + synchronized 同步关键字实现单例，kotlin的双重校验同步锁实现方式简单了太多了。
这里我们运用到了Kotlin的延迟属性 Lazy。Lazy是接受一个 lambda 并返回一个 Lazy 实例的函数，返回的实例可以作为实现延迟属性的委托： 第一次调用 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果， 后续调用 get() 只是返回记录的结果。

带入参的双重校验同步锁实现方式

//这里可以根据实际需求发生改变
class SingletonDemo private constructor(private val params: String) {
    companion object {
        @Volatile private var instance: SingletonDemo? = null
        fun getInstance(params: Int) =
                instance ?: synchronized(this) {
                    instance ?: SingletonDemo(params).also { 
                    	instance = it 
                    }
                }
    }
}

关于“?:”操作符，如果“?: ”左侧表达式非空，就返回其左侧表达式，否则返回右侧表达式。 请注意，当且仅当左侧为空时，才会对右侧表达式求值。

线程安全的懒汉式

class Singleton private constructor() {
    companion object {
        lateinit var instance: Singleton
            get() {
                if (field == null) {
                    field = Singleton ()
                }
                return field
            }
        @Synchronized
        fun get(): Singleton {
            return instance!!
        }
    }
}

上述代码中，我们可以发现在Kotlin实现中，我们让其主构造函数私有化并自定义了其属性访问器，其余内容大同小异。