Kotlin 5种单例模式

在Kotlin中实现单例模式有多种方法，以下是几种常见的方法：

1. 饿汉式
   饿汉式是最简单的一种实现方式，在类加载时就完成了实例的初始化。

//饿汉式
object Singleton1 {
    fun printMessage() {
        println("===饿汉式")
    }
}

2. 懒汉式
   懒汉式是延迟加载的方式，只有在第一次使用时才创建实例。

class Singleton2 private constructor() {

    companion object {
        private var instance: Singleton2? = null

        @Synchronized
        fun getInstance(): Singleton2 {
            if (instance == null) {
                instance = Singleton2()

            }
            return instance!!
        }
    }

    fun printMessage() {
        println("===懒汉式")
    }
}

3. 双重检查锁定
   双重检查锁定是一种更高效的懒汉式实现，通过双重检查锁定来确保线程安全。

class Singleton3 private constructor() {

    companion object {
        private var instance: Singleton3? = null;
        fun getInstance(): Singleton3 {
            if (instance == null) {
                synchronized(Singleton3::class.java) {
                    if (instance == null) {
                        instance = Singleton3()
                    }
                }
            }
            return instance!!
        }
    }

    fun printMessage() {
        println("===双重检查锁定")

    }
}

4. 静态内部类
   静态内部类是实现单例模式的另一种方式，利用了Java的类加载机制来保证线程安全。

//静态内部类
class Singleton4 private constructor() {

    companion object {
        private var instance: Singleton4? = null
        fun getInstance(): Singleton4 {
            return Holder.instance
        }

        private object Holder {
            val instance = Singleton4()
        }
    }
    fun printMessage() {
        println("===静态内部类")
    }
}

5. 枚举
   枚举是实现单例模式的最佳方法，它天生就是线程安全的，并且能够防止反序列化创建新的对象。

//枚举
enum class Singleton5 {

    INSTANCE;

    fun printMessage() {
        println("===枚举")
    }

}

fun main() {
    Singleton1.printMessage()
    Singleton2.getInstance().printMessage()
    Singleton3.getInstance().printMessage()
    Singleton4.getInstance().printMessage()
    Singleton5.INSTANCE.printMessage()
}
打印结果：
===饿汉式
===懒汉式
===双重检查锁定
===静态内部类
===枚举

以上就是在Kotlin中实现单例模式的几种常见方法。每种方法都有其优缺点，可以根据具体的需求选择合适的方法。