初识 Kotlin （五） ---- Kotlin 中 的单例模式

1. 饿汉模式: static final field

既然饿，那么在创建对象实例的时候就比较着急，于是在装载类的时候就创建对象实例

这种方法非常简单，因为单例的实例被声明成 static 和 final 变量了，在第一次加载类到内存中时就会初始化，所以创建实例本身是线程安全的。

//Java实现
public class Singleton{
	//类加载时就初始化
	private static final Singleton instance = new Singleton();
	private Singleton(){}
	public static Singleton getInstance(){
		return instance;
	}
}

Kotlin 引入了 object 类型，可以很容易声明单例模式

//Kotlin实现
object Singleton{
    fun test() {}
}

这种方式和 Java 单例模式的饿汉式一样，不过比 Java 中的实现代码量少很多，其实是个语法糖（Kotlin漫山遍野都是语法糖）。反编译生成的 class 文件后如下：

public final class Singleton {
   public static final Singleton INSTANCE;

   public final void test() {
   }

   private Singleton() {
   }

   static {
      Singleton var0 = new Singleton();
      INSTANCE = var0;
   }
}

//java 调用
Singleton.INSTANCE.test()

//kotlin
Singleton.test()

• 如果构造方法中有耗时操作的话，会导致这个类的加载比较慢。
• 饿汉式一开始就创建实例，但是并没有调用，会造成资源浪费。
• 还有一个 Java 饿汉式单例模式没有的问题：无法自定义构造函数，object 中不允许 constructor 函数, 需要使用使用 init{}

2. 懒汉模式：线程不安全

//Java实现
public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){}
    public static SingletonDemo getInstance(){
        if(instance == null){
            instance = new SingletonDemo();
        }
        return instance;
    }
}

//Kotlin实现
class SingletonDemo private constructor() {
    companion object {
        private var instance: SingletonDemo? = null
            get() {
                if (field == null) {
                    field = SingletonDemo()
                }
                return field
            }
            
        fun get(): SingletonDemo{
        	//细心的小伙伴肯定发现了，这里不用getInstance作为为方法名，
        	//是因为在伴生对象声明时，内部已有getInstance方法，所以只能取其他名字
            return instance!!
        }
    }
}

3. 线程安全的懒汉模式

//Java实现
public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){}
    public static synchronized SingletonDemo getInstance(){//使用同步锁
        if(instance == null){
            instance = new SingletonDemo();
        }
        return instance;
    }
}

//Kotlin实现
class SingletonDemo private constructor() {
    companion object {
        private var instance: SingletonDemo? = null
            get() {
                if (field == null) {
                    field = SingletonDemo()
                }
                return field
            }
            
        @Synchronized
        fun get(): SingletonDemo{
            return instance!!
        }
    }
}

大家都知道在使用懒汉式会出现线程安全的问题，需要使用同步锁，在 Kotlin 中，如果你需要将方法声明为同步，需要添加 @Synchronized 注解

4. 双重校验锁式

双重检验锁模式（double checked locking pattern），是一种使用同步块加锁的方法。程序员称其为双重检查锁，因为会有两次检查 instance == null，一次是在同步块外，一次是在同步块内。为什么在同步块内还要再检验一次？因为可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就会生成多个实例了。

//Java实现
public class Singleton{
	/**
	 * volatile保证了：
	 * 1. instance 在多线程下的并发可见性
	 * 2.禁止 instance 在操作时的指令重排序
	 */
	private volatile static Singleton instance = null;
	public static Singleton getIntance(){
		//第一次判空，保证不必要的同步
		if(instance == null){
			//synchronized对Singleton加全局锁，保证每次只要一个线程创建实例
			synchronized(Singleton.class){
				//第二次判空时为了在null的情况下创建实例
				if(instance == null){
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
}

具体原理参考：

• Java与Kotlin下的6种单例模式

//kotlin实现
class SingletonDemo private constructor() {
    companion object {
        val instance: SingletonDemo by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            SingletonDemo() 
        }
    }
}

具体实现原理可参考：

• Kotlin下的5种单例模式
• Java与Kotlin下的6种单例模式

5. 静态内部类式

这种方法也是《Effective Java》上所推荐的。

//Java实现
public class Singleton{
	private static class SingletonHolder{
		private static final Singleton INSTANCE = new Singleton();
	}
	
	private Singleton(){}
	
	public static final Singleton getInstance(){
		return SingletonHolder.INSTANCE;
	}
}

这种写法仍然使用 JVM 本身机制保证了线程安全的问题。

由于静态单例对象没有作为 Singleton 的成员变量直接实例化，因此类加载时不会实例化 Singleton，第一次调用 getInstance() 时将内部类 SingletonHodler，在该内部类中定义了一个 static 类型的变量 INSTANCE，此时会首先初始化这个成员变量，由 Java 虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于 getInstance() 方法没有任何线程锁定，因此其性能不会造成任何影响。

• 由于 SingletonHodler 是私有的，除了 getInstance() 之外没有办法访问它，因此它是懒汉式的
• 同时读取实例的时候不会进行同步，没有性能缺陷
• 也不依赖 JDK版本。

//Kotlin实现
class Singleton private constructor() {
    companion object {
        val instance = SingletonHolder.holder
    }
    private object SingletonHolder {
        val holder= Singleton()
    }
}

class Singletone private constructor() {
    init {
        println("Initializing with object: $this")
    }

    companion object {
        val getInstance =SingletonHolder.holder
    }

    private object SingletonHolder {
        val holder = Singletone()
    }

    fun print() = println("Printing with object: $this")
}

//usage
Singletone.getInstance.print()
Singletone.getInstance.print()

//output
Initializing with object: advance.Singletone@266474c2
Printing with object: advance.Singletone@266474c2
Printing with object: advance.Singletone@266474c2

6. 枚举式：Enum

//Java实现
public enum EasySingleton{
    INSTANCE;
}

创建枚举默认就是线程安全的，所以不需要担心 double checked locking，而且还能防止反序列化导致重新创建新的对象。

//Kotlin实现
enum class EasySingleton{
	INSTANCE;
}