Kotlin 中实现单例模式的几种常见模式

1 懒汉式，线程安全（伴生对象 + by lazy）

想“懒汉”一样，拖延到首次使用时才进行初始化。

通过 companion object 和 lazy 实现懒加载，首次访问是才进行初始化，lazy 默认使用 LazyThreadSafetyMode.SYNCHRONIZED，确保线程安全。

class Singleton private constructor() {
    companion object {
        val instance: Singleton by lazy {
            Singleton()
        }
    }
}

Java 中的懒汉模式，线程安全：

public class Singleton {

    private static Singleton instance;
    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

}

// 或者
public class Singleton {

    private static Singleton instance;
    private Singleton() { }

    public static Singleton getInstance() {
        synchronized (Singleton.class) {
            if (instance == null) {
                instance = new Singleton();
            }
        }

        return instance;
    }
}

2 懒汉式，双重检验锁（Double - Checked Locking）

通过 @Volatile 保证变量的可见性（对于变量的写操作会立即刷新到主内存中）和禁止指令重排序；通过同步代码块（synchronized）来确保线程安全。

实例在第一次被调用的时候才会被创建，实现了延迟初始化。

class Singleton private constructor() {

    companion object {
        @Volatile
        private var instance: Singleton? = null

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

Java 中的双重检验锁模式：

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {

    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

3 饿汉式（Object 关键字）

像“饿汉”一样，立即进行初始化。

这是 Kotlin 中最简洁的单例实现方式，Kotlin 编译器会保证线程安全和单例的创建。单例类在类加载时就被初始化。

object Singleton {
  	
}

将其反编译成 Java 代码：

public final class Singleton {
   @NotNull
   public static final Singleton INSTANCE;

   private Singleton() {
   }

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

Java 中的饿汉模式：

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {

    }

    public static Singleton getInstance() {
        return instance;
    }
}

4 静态内部类（Holder 模式）

静态内部类只有在使用的时候才会被加载，从而实现了延迟初始化。通过 Kotlin 的类加载机制保证线程安全。

class Singleton private constructor() {
    companion object {
        val instance: Singleton by lazy { Holder.instance }
    }

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

Java 中的静态内部类：

public class Singleton {
    private Singleton() {

    }

    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }

    private static class Holder {
        private static Singleton INSTANCE = new Singleton();
    }
}