Kotlin中的几种单例模式

1. 常见的几种单例模式

单例模式是咱们平常用到的频率比较高的设计模式，常见有如下几种类型:

1 饿汉单例
2 懒汉单例
3 线程安全的懒汉单例
4 双重校验模式
5 静态内部类模式

这篇文章主要介绍一下这几种单例模式在Java以及Kotlin中的不一样实现方式

2. 饿汉单例

//Java实现
public class SingletonDemo {
    private static SingletonDemo instance=new SingletonDemo();
    private SingletonDemo(){

    }
    public static SingletonDemo getInstance(){
        return instance;
    }
}
//Kotlin实现
object SingletonDemo
复制代码

没错，kotlin中实现饿汉单例只须要在类名前面加上一个object关键字就能够了。由于kotlin中是没有静态方法的概念的，因此就没有办法建立相似java实现方式中的getInstance()这样的静态方法。可是kotlin提供了更加简洁的方式达到相同的效果，就是使用object关键字。、

3. 懒汉单例

//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{
         return instance!!
        }
    }
}
复制代码

kotlin实现懒汉单例的关键点有两个:1 主构造器私有化 2 使用自定义访问器返回对象实例

4. 线程安全的懒汉单例

//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!!
        }
    }

}
复制代码

内容基本与懒汉模式相同，惟一的区别就是Java使用为方法添加同步锁的方式实现，kotlin须要在方法中添加 @Synchronized注解。

5. 双重校验锁

//Java实现
public class SingletonDemo {
    private volatile static SingletonDemo instance;
    private SingletonDemo(){} 
    public static SingletonDemo getInstance(){
        if(instance==null){
            synchronized (SingletonDemo.class){
                if(instance==null){
                    instance=new SingletonDemo();
                }
            }
        }
        return instance;
    }
}
//kotlin实现
class SingletonDemo private constructor() {
    companion object {
        val instance: SingletonDemo by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
        SingletonDemo() }
    }
}
复制代码

Java中的双重校验锁模式就是在同步锁模式的基础上稍做改动，添加了双重判断，而且将同步锁的做用域进一步缩小到了方法内部进行第二重判断以前。而kotlin中双重校验锁的实现更加简单，直接使用lazy结合属性委托的方式实现。

6. 静态内部类模式

//Java实现
public class SingletonDemo {
    private static class SingletonHolder{
        private static SingletonDemo instance=new SingletonDemo();
    }
    private SingletonDemo(){
        System.out.println("this is a singleton model");
    }
    public static SingletonDemo getInstance(){
        return SingletonHolder.instance;
    }
}
//kotlin实现
class SingletonDemo private constructor() {
    companion object {
        val instance = SingletonHolder.holder
    }

    private object SingletonHolder {
        val holder= SingletonDemo()
    }
}
复制代码

kotlin和java的实现方式基本相同