【设计模式一】Java和Kotlin中的单例模式（饿汉、懒汉、静态内部类）

单例模式的优点：

1. 在内存中只有一个对象，节约内存
2. 避免频繁的创建和销毁对象，可以提高性能
3. 避免对共享资源的多重占用
4. 可以全局访问

适用场景：

1. 需要频繁实例化然后销毁的对象
2. 创建对象时，耗时过多或者耗资源过多，但又经常用到的对象
3. 有状态的工具类对象
4. 频繁访问数据库或文件的对象
5. 要求只有一个对象的场景

1. 饿汉单例

• java

public class Singleton {
    private Singleton() {
    }

    private static Singleton instance = new Singleton();

    public static Singleton getInstance() {
        return instance;
    }
}

• kotlin

object Singleton {
    
}

2. 懒汉单例

• java

public class Singleton {
    
    private Singleton() {
    }

    private static Singleton instance;

    public static Singleton getInstance() {
        if (instance != null) {
            instance = new Singleton();
        }
        return instance;
    }
    
}

• java懒汉线程安全，方法前加上了synchronized关键字

public class Singleton {

    private Singleton() {
    }

    private static Singleton instance;

    public static synchronized Singleton getInstance() {
        if (instance != null) {
            instance = new Singleton();
        }
        return instance;
    }

}

• kotlin

class Singleton private constructor() {

    //kotlin中没有静态方法所以用伴生对象
    companion object {

        //重写变量的get方法
        private var instance: Singleton? = null
            get() {
                if (field == null){
                    field = Singleton()
                }
                return field
            }

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

• kotlin懒汉线程安全，多了一个Synchronized注解

class Singleton private constructor() {

    //kotlin中没有静态方法所以用伴生对象
    companion object {

        //重写变量的get方法
        private var instance: Singleton? = null
            get() {
                if (field == null){
                    field = Singleton()
                }
                return field
            }

        @Synchronized
        fun get(): Singleton {
            return instance!!
        }
    }
    
}

3. 静态内部类单例

• java

/*
 * 三个优点
 * 1.jvm虚拟机本身的机制，保证了数据的线程安全
 * 2.没有使用关键字，synchronized，虽然这个关键字能保证线程安全，但是他非常的影响性能，
 * 因为他只有一个线程能读取里面的数据，另一个线程就不能读取，静态内部类的方式，可以同时读取
 * jvm本身的机制保证了线程安全，没有性能缺陷
 * 3.SingletonHolder类是私有的，只有getInstance()能对其进行访问
 */

/*
 * 第一次加载这个StaticInnerSingleton的时候，他不会初始化instance， 只有他第一次调用 getInstance()
 * 这个方法之后，虚拟机才会加载SingletonHolder类， 并初始化instance，这样不仅能保证线程安全，也能保证single类的唯一性。
 */


/**
    // 静态内部类
 * jvm提供的同步控制 static final static 区块初始化数据，保证数据在内存中是独一份的 final
 * 变量初始化完成之后就无法被修改，所以final也是线程安全的
 *
 * 我们利用的是jvm进行类加载的时候会保证数据同步，所以我们就利用内部类原理，
 * 在内部类里创建对象的实例，这样只要我们的应用中不使用这个内部类StaticInnerSingleton，
 * 那么jvm虚拟机他就不会去加载这个类，也就不会去创建我们所要创建的单例对象Instance，从而
 * 这里静态内部类，就完成了懒汉式的延迟加载，同时又保证了线程安全
 */

public class StaticInnerSingleton {
    private StaticInnerSingleton() {
    }

    private static class SingletonHolder {
        private static final StaticInnerSingleton mInstance = new StaticInnerSingleton();
    }
    
    public static StaticInnerSingleton getInstance() {
        return SingletonHolder.mInstance;
    }
}

• kotlin

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

    private object SingletonHolder {
        val holder= Singleton()
    }

}

4. 双重校验锁（Double Check）

• java

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

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

5. 枚举单例

public enum GetIatResult {

    //定义一个枚举元素，他就是该类的一个实例。
    INSTANCE;

    public void start(){

    }

}