1、Java版本饿汉式与Kotlin版本饿汉式

Java版本

package s1;

//饿汉式
public class SingleTon {

    private static SingleTon instance = new SingleTon();

    public SingleTon() {
    }

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

Kotlin版本

//KT 饿汉式
object SingleTonKt

那么Kotlin转化里干了什么呢？

Kotlin在虚拟机里自动生成了INSTANCE,进行了初始化

2、Java版本懒汉式与Kotlin版本懒汉式

java版本

//Java懒汉式版本
public class SingleTon2 {

    private static SingleTon2 instance;

    public SingleTon2() {
    }

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

Kotlin版本

//Kt没有静态概念，使用派生
class SingleTonKt2 {

    companion object{

        private var instance : SingleTonKt2?=null
            get() {
                if (field == null){
                    field = SingleTonKt2()
                }
                return field
            }
        fun getInstanceKt(): SingleTonKt2? = instance!!

    }

    fun show(){
        println("show")
    }

}

fun main() {
    SingleTonKt2.getInstanceKt()?.show()
}

那么Kotlin做了哪些呢？

可以看到，虚拟机自动生成了getInstance(),并且我们重写时候，会把getInstance()当参数进行返回

3、Java版本懒汉式与Kotlin版本懒汉式(线程安全)

Java版本

//安全懒汉式
public class SingleTon3 {

    private static SingleTon3 instance;

    public SingleTon3() {
    }

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

Kotlin版本

class SingltTonKt3 private constructor(){

    companion object{

        private var instance : SingltTonKt3?=null
            get() {
                if (field == null){
                    field = SingltTonKt3()
                }
                return field
            }
        @Synchronized
        fun getInstanceKt(): SingltTonKt3? = instance!!

    }

}

此处的field = instance,加锁的注解，在虚拟机里会给我们在方法上加锁

4、Java版本懒汉式与Kotlin版本懒汉式(双重校验)

Java版本

//双重校验安全
public class SingleTon4 {

    private volatile static SingleTon4 instance;

    public SingleTon4() {
    }

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

                }
            }


        return instance;
    }
}

Kotlin版本

class SingleTonKt4 private constructor(){

    companion object{
        val instance2 : SingleTonKt4 by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED){ SingleTonKt4()}
    }

    fun show(){
        println("show")
    }

}

fun main(){
    SingleTonKt4.instance2.show()
}

那么，这个Kotlin在虚拟机里做了什么呢？

可以看到，生成的变量先使用懒加载的方式，然后通过LazyKt.lazy(),进去看看这个里面做了什么？

可以看到里面有三种，其中一种是含锁机制。

可以看到，也是锁的对象，进行安全机制的加载。

5、静态内部类实现的单例模式

class Singleton private constructor(){

    companion object{
        val instance = Holder.instance
    }

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