Kotlin设计模式之单例模式

一. 使用object关键字

Kotlin提供了object关键字来直接创建单例对象，这是最简单和推荐的方式。

// SingletonObject.kt
object SingletonObject {
    fun doSomething() {
        println("Doing something...")
    }
}

二. 使用companion object

companion object可以用于在类中创建单例实例。

// SingletonCompanion.kt
class SingletonCompanion private constructor() {
    companion object {
        private var instance: SingletonCompanion? = null

        fun getInstance(): SingletonCompanion {
            if (instance == null) {
                instance = SingletonCompanion()
            }
            return instance!!
        }
    }

    fun doSomething() {
        println("Doing something...")
    }
}

三. 使用lazy初始化

使用lazy委托属性来实现线程安全的单例模式。

// SingletonLazy.kt
class SingletonLazy private constructor() {
    companion object {
        val instance: SingletonLazy by lazy { SingletonLazy() }
    }

    fun doSomething() {
        println("Doing something...")
    }
}

四. 双重检查锁定（Double-Checked Locking）

这种方式在Kotlin中不常用，因为Kotlin的lazy已经提供了线程安全的实现。

// SingletonDoubleChecked.kt
class SingletonDoubleChecked private constructor() {
    companion object {
        @Volatile
        private var instance: SingletonDoubleChecked? = null

        fun getInstance(): SingletonDoubleChecked {
            return instance ?: synchronized(this) {
                instance ?: SingletonDoubleChecked().also { instance = it }
            }
        }
    }

    fun doSomething() {
        println("Doing something...")
    }
}

五. 使用Synchronized关键字

这种方式确保线程安全，但性能不如lazy。

// SingletonSynchronized.kt
class SingletonSynchronized private constructor() {
    companion object {
        private var instance: SingletonSynchronized? = null

        @Synchronized
        fun getInstance(): SingletonSynchronized {
            if (instance == null) {
                instance = SingletonSynchronized()
            }
            return instance!!
        }
    }

    fun doSomething() {
        println("Doing something...")
    }
}

总结

• object关键字：最简单和推荐的方式，线程安全。

• companion object：适用于需要在类中创建单例的情况。

• lazy初始化：提供线程安全的单例实现。

• 双重检查锁定：提供线程安全的单例实现，但在Kotlin中不常用。

• Synchronized关键字：确保线程安全，但性能不如lazy。

根据具体需求选择合适的单例实现方式。