1. 饿汉式
直接使用对象表达式object就可以方便的实现

object Singleton {
    ...
}

//调用时
Singleton.xxx

这种方式实际上是使用Java静态代码块在类加载时初始化类中INSTANCE静态对象实例

public final class Singleton {
    public static final Singleton INSTANCE = null;
    static {
        Singleton singleton = new Singleton();
    }
    private Singleton() {
        INSTANCE = this;
    }
}

所以在Java下调用时

Singleton.INSTANCE.xxx

2. 懒汉式

• 构造时不传参数
  如果在对象构造时不需要传参数，那使用Kotlin标准库提供的延迟属性 Lazy可以很方便实现

class Singleton private constructor(){

    object Holder{
        val INSTANCE=Singleton()
    }

    companion object {
        val instance by lazy { 
            Holder.INSTANCE
        }
    }

    xxx
}


// Kotlin 中调用
Singleton.instance.xx()
// Java 中调用
Singleton.Companion.getInstance().xx()

延迟属性 Lazy 默认线程安全模式是 LazyThreadSafetyMode.SYNCHRONIZED，使用双重检验锁来保证线程安全

• 构造时传参数
  上面两种方式都很方便，但都不能在获取单例时传入参数，如果想要传参数，可以在伴随对象中写方法自己保证线程安全，这里采用双重检验锁实现

class Singleton private constructor(arg: String){

    companion object {
        @Volatile private var instance: Singleton? = null
        
        public fun getInstance(arg: String): Singleton{
            if (instance == null) {
                synchronized(Singleton::class){
                    if (instance == null) {
                        instance=Singleton(arg)
                    }
                }
            }
            return instance!!
        }
    }
}

@Volatile为了防止指令重拍造成的影响