六种单例模式
- 1. 饿汉模式: static final field
- 2. 懒汉模式：线程不安全
- 3. 线程安全的懒汉模式
- 4. 双重校验锁式
- 5. 静态内部类式
- 6. 枚举式：Enum
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;
}
}
具体原理参考：
//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;
}
