kotlin 单利模式

1. 懒汉式

java
线程不安全 缺点是在多线程不能正常工作

public class Singleton {

    private static Singleton singleton;

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

    private Singleton() {
    }
}

线程安全 效率比较低

public class Singleton {

    private static Singleton singleton;

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

    private Singleton() {

    }
}

kotlin
线程不安全

class SingletonKotlin private constructor() {

    companion object {
        private var singleton: SingletonKotlin? = null
            get() {
                // field 幕后属性或幕后字段  
                // 作用域仅仅存在于当前属性的setter/getter方法中，它就像当前属性的影子一样
                if (field == null) {
                    field = SingletonKotlin()
                }
                return field
            }

        fun get(): SingletonKotlin {
            return singleton!!
        }
    }
}

线程安全

class SingletonKotlin private constructor() {

    companion object {
        private var singleton: SingletonKotlin? = null
            get() {
                // field 幕后属性或幕后字段
                // 作用域仅仅存在于当前属性的setter/getter方法中，它就像当前属性的影子一样
                if (field == null) {
                    field = SingletonKotlin()
                }
                return field
            }
        
        @Synchronized
        fun get(): SingletonKotlin {
            return singleton!!
        }
    }
}

2. 饿汉式 先创建实例，直接使用，避免了多线程的同步问题

java

public class Singleton {

    private static Singleton singleton = new Singleton();

    public static synchronized Singleton getInstance() {
        return singleton;
    }

    private Singleton() {

    }
}

public class Singleton {

    private static Singleton singleton;

    static {
        singleton = new Singleton();
    }


    public static synchronized Singleton getInstance() {
        return singleton;
    }

    private Singleton() {

    }
}

两种写法都差不多，都是先创建实例 然后直接使用
kotlin

object SingletonKotlin

3. 双重校验模式

写法比较麻烦
java

public class Singleton {

    private static Singleton singleton;

    private Singleton() {
    }

    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

kotlin

class SingletonKotlin private constructor() {
    // by lazy延迟加载
    val instance: SingletonKotlin by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
        SingletonKotlin()
    }
}

4. 静态内部类

延迟加载，减少内存开销
java

public class Singleton {
    private Singleton() {
    }

    private static class Instance {
        private static final Singleton singleton = new Singleton();
    }

    public static synchronized Singleton getInstance() {
        return Instance.singleton;
    }
}

kotlin

class SingletonKotlin private constructor() {
    companion object {
        var singleton = SingletonKotlin.instance
    }

    private object SingletonKotlin {
        val instance = SingletonKotlin()
    }
}

5. 枚举类单利模式

不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。但是没有延迟加载

public enum Singleton {
    SINGLETON;

    public void test() {
        // 要做的事情
    }
}