java/ kotlin下的单例模式

单例模式属于创建型模式， 顾名思义，就是说整个系统中只有一个该对象的实例。

为什么要使用单例模式？

1， 对于一些需要频繁创建，销毁的对象， 使用单例模式可以节省系统资源

2， 对于全局持有的对象，单例模式方便控制

实现单例模式的关键？

1， 构造方法私有，阻止对象被外部随意创建

2， 以静态方法返回实例， 因为无法从外部创建，所以要提供静态方法返回实例

3， 确保实例只有1个， 只对类进行一次实例化，以后都取第一次实例化的对象

单例模式常见写法

• 饿汉式

public class EHan {

    //类加载时实例化对象
    private static EHan instance = new EHan();

    //构造方法私有
    public EHan() {

    }
    //提供静态方法供外部调用返回该类的实例
    public static EHan getInstance() {
        return instance;
    }

    public void eat(){
        System.out.println("eat...");
    }
}
饿汉式单例就是在类初始化时就实例化对象，后面要用的时候直接拿去用就行。 它的优点是线程安全，没有加锁，执行效率高。缺点是没有懒加载，如果这个类自始至终没有真正使用过，那就是浪费了内存
那么饿汉式单例在kotlin中怎么写呢？ 我们直接使用studio的一键转换功能，得到如下代码

class EHan {
    fun eat() {
        println("eat...")
    }

    companion object {
        val instance = EHan()
    }
}
其实在kotlin中还可以写得更简单：

object EHan {
    fun eat() {
        println("eat...")
    }
}
一个object关键字就申明了饿汉式单例， 为了证明， 我们可以通过studio查看上述代码的字节码
tools--> kotlin--> show kotlin Bytecode.  --> DeCompile 得到结果如下

这是因为在kotlin中，类没有静态方法. object关键字在kotlin中有两种使用场景， 对象表达式和对象声明。对象声明就是在kotlin中声明单例的方式

上面的companion object也是一样的道理， 不同的是 伴生对象在整个类中只能有1个

• 懒汉式

懒汉式分为线程安全的和线程不安全的， 我们先来看不安全的

public class LanHan {

    private static LanHan instance;

    //构造方法私有
    private LanHan(){

    }
    
    //提供静态方法返回实例
    public static LanHan getInstance(){
        //如果为空就去实例化， 否则返回instance
        if (instance == null) {
            instance = new LanHan();
        }
        return instance;
    }
}
它对应的在kotlin中的写法如下：

class LanHan private constructor() {
   companion object {
       private var instance: LanHan? = null
       get() {
           if (field == null) {
               field = LanHan()
           }
           return field
       }

       fun get(): LanHan {
           return instance!!
       }
   }
}

这种写法，如果某个线程执行到if (instance == null) 还没来得及往下执行时，另一个线程也执行到了这里，那么就会创建两个实例， 所以是线程不安全的。
那么如何让它线程安全呢？答案是synchronized关键字

public class LanHan {

    private static LanHan instance;

    //构造方法私有
    private LanHan(){

    }

    //提供静态方法返回实例
    public static LanHan getInstance(){
        //加锁， 防止多个线程同时执行实例化
        synchronized (LanHan.class){
            //如果为空就去实例化， 否则返回instance
            if (instance == null) {
                instance = new LanHan();
            }
        }
        return instance;
    }
}
在kotlin中的写法：

class LanHan private constructor() {
   companion object {
       private var instance: LanHan? = null
       get() {
           if (field == null) {
               field = LanHan()
           }
           return field
       }
       
       @Synchronized
       fun get(): LanHan {
           return instance!!
       }
   }
}

在kotlin中，@Synchronized注解表明给该方法加同步锁

加锁之后， 实现了线程安全， 多个线程执行到这里时要排队等待， 这又严重影响了性能， 怎么解决呢？

方案一： 双重锁（DCL）
所谓双重锁就是判断两次if(instance == null), 只有等于null时才上锁

public static LanHan getInstance(){
    //只有对象未创建时才上锁
    if (instance == null){
        //加锁， 防止多个线程同时执行实例化
        synchronized (LanHan.class){
            //如果为空就去实例化， 否则返回instance
            if (instance == null) {
                instance = new LanHan();
            }
        }
    }
    return instance;
}

DCL是完美的解决了单例模式中性能和资源浪费的问题，但是DCL在并发情下也会存在一个问题，因为Jvm指令是乱序的；

情况如下：

线程1调用getInstance 获取对象实例，因为对象还是空未进行初始化，此时线程1会执行new Singleton()进行对象实例化，而当线程1的进行new Singleton()的时候JVM会生成三个指令。

指令1:分配对象内存。

指令2:调用构造器，初始化对象属性。

指令3:构建对象引用指向内存。

因为编译器会自作聪明的对指令进行优化， 指令优化后顺序会变成这样:

1、执行指令1：分配对象内存，

2、执行指令3：构建对象引用指向内存。

3、然后正好这个时候CPU 切到了线程2工作，而线程2此时也调用getInstance获取对象，那么线程2将执行下面这个代码 if (singleton == null)，此时线程2发现对象不为空（因为线程1已经创建对象引用并分配对象内存了），那么线程2会得到一个没有初始化属性的对象（因为线程1还没有执行指令2）。

所以在这种情况下，双检测锁定的方式会出现DCL失效的问题。

那么双重锁在kotlin代码里怎么写呢， 我们先直接一键转换看一下

object LanHan {
    var instance: LanHan? = null
        get() {
            if (field == null) {
                synchronized(LanHan::class.java) {
                    if (field == null) {
                        field = LanHan
                    }
                }
            }
            return field
        }
        private set
}
看起来是不是很messy, 有没有更优雅的写法呢， 百度了一下果然有

class LanHan private constructor() {
    companion object {
        val instance: LanHan by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            LanHan()
        }
    }
}

这个看起来就简洁多了， 这里有个知识点就是lazy
Lazy是接受一个 lambda 并返回一个 Lazy 实例的函数，返回的实例可以作为实现延迟属性的委托：第一次调用 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果， 后续调用 get() 只是返回记录的结果。

（摘自 什么是单例模式_东非大裂谷的博客-CSDN博客_什么是单例模式）

方案二： 静态内部类

public class LanHan {

    //构造方法私有
    private LanHan(){}

    //静态内部类
    private static class LanHanHolder{
        //内部类第一次访问时创建对象实例
        private static LanHan instance = new LanHan();
    }
    
    public static LanHan getInstance(){
        return LanHanHolder.instance;
    }
}
因为当外部类被访问时并不会加载内部类， 所以只有在访问LanHanHolder这个内部类时才会去实例化对象，这就实现了懒加载的效果.但是静态内部类的方式只适用于静态域
可以看到单例模式的各种写法里都用到了static关键字， 这是因为static修饰的语句/代码块在整个类加载过程中只执行一次。

那么静态内部类在kotlin中怎么写呢？

class LanHan private constructor() {

    private object LanHanHolder {
        val holder = LanHan()
    }

    companion object{
        val instance = LanHanHolder.holder
    }
}

• 枚举

public enum MeiJu {
    INSTANCE;
    public void run(){
    }
}
这是一种非常简单的单例实现， 避免了线程同步问题，支持自动序列化机制，且绝对不会多次实例化
枚举的特性：
1， 它不能有public的构造函数， 这样就保证了其他代码没有办法新建一个enum实例。
2，所有枚举值都是public, static, final 的
3， Enum默认实现了jave.lang.comparable接口
4， Enum覆载了toString方法
5， Enum提供了valueOf方法， 用于从string中读取枚举类型
6， Enum提供了values方法， 用来遍历所有的枚举值

枚举在kotlin中的写法和java大同小异， 不再赘述

enum class MeiJu {
    INSTANCE;
    fun run() {}
}

（kotlin部分参考 Kotlin下的5种单例模式，看了都说好！_程序员小乐-CSDN博客 感谢博主）