Java 和Kotlin的單例模式其實(shí)很像，只是Kotlin一部分單例可以用對象類和委托l(wèi)azy來實(shí)現(xiàn)

Java

/**
 * 懶漢式，線程不安全
 */
class Singleton {
    private static Singleton instance;
    private Singleton() {
    }
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

/**
 * 懶漢式，線程安全
 */
class Singleton1 {
    private static Singleton1 instance;
    private Singleton1() {
    }
    public static synchronized Singleton1 getInstance() {
        if (instance == null) {
            instance = new Singleton1();
        }
        return instance;
    }
}

/**
 * 餓漢式
 */
class Singleton2 {
    private static Singleton2 instance = new Singleton2();
    private Singleton2() {
    }
    public static Singleton2 getInstance() {
        return instance;
    }
}

/**
 * 雙檢鎖/雙重校驗(yàn)鎖（DCL，即 double-checked locking）
 */
class Singleton3 {
    private volatile static Singleton3 singleton;
    private Singleton3() {
    }
    public static Singleton3 getSingleton() {
        if (singleton == null) {
            synchronized (Singleton3.class) {
                if (singleton == null) {
                    singleton = new Singleton3();
                }
            }
        }
        return singleton;
    }
}

/**
 * 登記式/靜態(tài)內(nèi)部類
 */
class Singleton4 {
    private static class SingletonHolder {
        private static final Singleton4 INSTANCE = new Singleton4();
    }
    private Singleton4() {
    }
    public static final Singleton4 getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

/**
 * 枚舉
 */
enum Singleton5 {
    INSTANCE2;
    public void whateverMethod() {
        System.out.println("....");
    }
}

Kotlin

/**
 * 懶漢式，線程不安全，仿Java
 */
internal class Singleton6 private constructor() {
    companion object {
        private var instance: Singleton6? = null

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

/**
 * 懶漢式，線程不安全
 */
internal class Singleton7 private constructor() {
    companion object {
        var instance: Singleton7? = null
            get() {
                if (field == null) {
                    field = Singleton7()
                }
                return field
            }

    }
}

/**
 * 懶漢式，線程安全
 */
internal class Singleton8 private constructor() {
    companion object {
        @get:Synchronized
        var instance: Singleton8? = null
            get() {
                if (field == null) {
                    field = Singleton8()
                }
                return field
            }
    }
}

/**
 *餓漢式
 */
internal object Singleton9 {
    fun whateverMethod() {
        println("....")
    }
}

/**
 *餓漢式，仿Java
 */
internal class Singleton10 private constructor() {
    companion object {
        val instance = Singleton10()
    }
}

/**
 * 雙檢鎖/雙重校驗(yàn)鎖（DCL，即 double-checked locking）
 */
internal class Singleton12 private constructor() {
    companion object {
        val instance: Singleton12 by lazy {
            Singleton12()
        }
    }
}

/**
 * 雙檢鎖/雙重校驗(yàn)鎖（DCL，即 double-checked locking）,仿Java
 */
internal class Singleton11 private constructor() {
    companion object {
        @Volatile
        var instance: Singleton11? = null
            get() {
                if (field == null) {
                    synchronized(Singleton11::class) {
                        if (field == null) {
                            field = Singleton11()
                        }
                    }
                }
                return field
            }
    }
}

/**
 * 登記式/靜態(tài)內(nèi)部類
 */
internal class Singleton13 {
    private object SingletonHolder {
        val INSTANCE = Singleton13()
    }

    companion object {
        val instance: Singleton13
            get() = SingletonHolder.INSTANCE
    }
}

/**
 * 枚舉
 */
internal enum class Singleton14 {
    INSTANCE;

    fun whateverMethod() {
        println("....")
    }
}