1. 使用object

object ObjectTest {
    init {
        println("ObjectTest init")
    }
    fun test() {
        println("ObjectTest test")
    }
}

然后看看编译的字节码对应的java代码

public final class ObjectTest {
   @NotNull
   public static final ObjectTest INSTANCE = new ObjectTest();
   private ObjectTest() {
   }
   public final void test() {
      String var1 = "ObjectTest test";
      System.out.println(var1);
   }
   static {
      String var0 = "ObjectTest init";
      System.out.println(var0);
   }
}

可以看见是一个饿汉式的单例模式，线程安全。这里的ObjectTest init，被编译成了static静态代码块，会在类加载的时候执行。

2. 使用companion object

class SingletonManager private constructor() {
    init {
        println("SingletonManager init")
    }
    companion object {
        val instance by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
            SingletonManager()
        }
    }
}

编译的字节码对应的java代码

public final class SingletonManager {
    @NotNull
    public static final Companion Companion = new SingletonManager.Companion((DefaultConstructorMarker)null);
    @NotNull
    private static final Lazy instance$delegate;
    private SingletonManager() {
        String var1 = "SingletonManager init";
        System.out.println(var1);
    }
    public SingletonManager(DefaultConstructorMarker $constructor_marker) {
        this();
    }
    static {
        instance$delegate = LazyKt.lazy(LazyThreadSafetyMode.SYNCHRONIZED, (Function0)null.INSTANCE);
    }
    public static final class Companion {
        private Companion() {
        }
        @NotNull
        public final SingletonManager getInstance() {
            Lazy var1 = SingletonManager.instance$delegate;
            Object var2 = null;
            return (SingletonManager)var1.getValue();
        }
        public Companion(DefaultConstructorMarker $constructor_marker) {
            this();
        }
    }
}

可以看见是懒汉式的，通过lazy初始化的，线程是否安全，取决于LazyThreadSafetyMode参数，默认是SYNCHRONIZED是线程安全的

3. 双检锁/双重校验锁

class SingletonManager private constructor() {
    companion object {
        @Volatile
        private var instance: SingletonManager? = null
        fun getInstance(): SingletonManager =
            instance ?: synchronized(this) {
                instance ?: SingletonManager().also { instance = it }
            }
    }
}

和java的双重校验锁类似，懒汉，线程安全

4. 静态内部类

class SingletonManager private constructor() {
    init {
        println("ObjectTest init")
    }
    companion object {
        fun getInstance() = Holder.INSTANCE
    }
    private object Holder {
        val INSTANCE = SingletonManager()
    }
}

和java的静态内部类类似，懒汉，线程安全

5. 枚举 不详细介绍