设计模式 学习笔记 单例模式

单例模式是最简单的设计模式之一，这种设计模式的意图就是保证一个类仅有一个实例，并提供一个访问它的全局访问点。已解决一个全局使用的类频繁的创建于销毁的问题，缺点是没有接口，不能继承，与单一职责原则冲突，一个类只应关系内部逻辑，而不关心外面怎么样来实例化。

1，懒汉式，线程不安全

是否lazy初始化：是

是否多线程安全：否

这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁synchronized，所以严格意义上来说并不算单例模式。

class SingleDemo private constructor(){
    companion object {
        private var instance : SingleDemo ?= null
            get() {
                if (field == null){
                    field = SingleDemo()
                }
                return field
            }
        fun getInstances(): SingleDemo{
            return instance!!
        }
    }
    fun showMessage(){
        println("Show Message")
    }
}
fun main(){
    val objecr = SingleDemo.getInstances()
    objecr.showMessage()
    val objecr2 = SingleDemo.getInstances()
    objecr2.showMessage()
}

2.懒汉式，线程安全

是否lazy初始化：是

是否多线程安全：是

这种方式具备很好的lazyloading，能够在多线程中很好的工作，但是，效率很低，99%情况下不需要同步。

优点：第一次调用才初始化，避免内存浪费

缺点：必须加锁synchronized才能保证单例，但加锁会影响效率

class SingleDemo private constructor(){
    companion object {
        private var instance : SingleDemo ?= null
            get() {
                if (field == null){
                    field = SingleDemo()
                }
                return field
            }
        @Synchronized
        fun getInstances(): SingleDemo{
            return instance!!
        }
    }
    fun showMessage(){
        println("Show Message")
    }
}
fun main(){
    val objecr = SingleDemo.getInstances()
    objecr.showMessage()
    val objecr2 = SingleDemo.getInstances()
    objecr2.showMessage()
}

3.饿汉式

是否lazy初始化：否

是否多线程安全：是

这种方式比较常用，但容易产生垃圾对象。

优点：没有加锁，执行效率会提高

缺点：类加载时就初始化，浪费内存

4.双重校验锁

是否lazy初始化：是

是否多线程安全：是

这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

class SingleDemo private constructor() {
    companion object{
        val instance: SingleDemo by lazy(
            mode = LazyThreadSafetyMode.SYNCHRonIZED
        ){
            SingleDemo()
        }
    }
    fun showMessage(){
        println("djmowiueqown")
    }
}
fun main(){
    val objecr = SingleDemo.instance
    objecr.showMessage()
    val objecr2 = SingleDemo.instance
    objecr2.showMessage()
}

5.静态内部类

是否lazy初始化：是

是否多线程安全：是

这种方式能达到双检锁一样的功效，但实现更简单。对静态域使用延迟初始化

class SingleDemo private constructor() {
    companion object {
        val instance = SingletonHolder.holder
    }
    private object SingletonHolder{
        val holder = SingleDemo()
    }
    fun showMessage(){
        println("djmowiueqown")
    }
}
fun main(){
    val objecr = SingleDemo.instance
    objecr.showMessage()
    val objecr2 = SingleDemo.instance
    objecr2.showMessage()
}