Kotlin单例方法

这篇文章简单介绍下kotlin中单例的实现方法。

1：饿汉式

java的实现很简单，我们直接上代码：

public class SingleTon1 {
    private static SingleTon1 singleTon1 = new SingleTon1();

    private SingleTon1() {
    }

    public static SingleTon1 getInstance() {
        return singleTon1;
    }
}

那kotlin怎么写呢？
这里就更简单了，只用到object关键字就行：

object SingleTon1 {
}

这就是kotlin中的饿汉式单例。
这里我们简单看下字节码文件：
怎么看呢？
首先我们找到studio的tools->kotlin然后点击show kotlin bytecode：


右侧会出现 kotlin bytecode，点击就可以了。

接着我们点击decompile，

2：懒汉式

我们还是先看下java的写法：

/**
 * create by zj on 2020/7/1
 * 懒汉式
 */
public class SingleTon2 {
    private static SingleTon2 singleTon;

    private SingleTon2() {
    }

    public static SingleTon2 getInstance() {
        if (singleTon == null) {
            singleTon = new SingleTon2();
        }
        return singleTon;
    }
}

kotlin这里就有两种写法了，我们完全可以照着java的模式来写一个：

class SingleTon2 {
    companion object {
        private var instance2: SingleTon2? = null
        fun getInstance(): SingleTon2 {
            if (instance2 == null) {
                instance2 = SingleTon2()
            }
            return instance2!!
        }
    }
}

另一种就是完全是kotlin独有了，这里我们用到的lazy。

class SingleTon2 {
    companion object {
        //LazyThreadSafetyMode.NONE 没有锁
       val instance by lazy(LazyThreadSafetyMode.NONE) {
           SingleTon2()
      }
    }
}

3：同步锁

public class SingleTon3 {
    private static SingleTon3 instance;

    private SingleTon3() {
    }

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

我们知道这样就实现了线程安全的懒加载，kotlin中跟java类似，只是synchronized来替换。

class SingleTon3 {
    companion object {
        private var instance: SingleTon3? = null

        @Synchronized
        fun getInstance(): SingleTon3 {
            if (instance == null) {
                instance = SingleTon3()
            }
            return instance!!
        }
    }
}

4：Double Check（优化的线程安全单例）
再上一步中getInstance方法我们直接加了synchronize同步，在这里我们则将synchronize加载方法里面，只有在实例为空的时候，才同步。

public class SingleTon4 {
    private static volatile SingleTon4 instance;

    private SingleTon4() {
    }

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

kotlin这里也有两种写法：

class SingleTon4 {
    companion object {
        @Volatile
        private var instance: SingleTon4? = null

        fun getInstance(): SingleTon4 {
            if (instance == null) {
                synchronized(this) {
                    if (instance == null) {
                        instance = SingleTon4()
                    }
                }
            }
            return instance!!
        }
 
    }
}

这里volatile也是使用注解的方法来表示、
那么kotlin中的正规写法是什么呢？
在第二种方法里面我们有见到LazyThreadSafetyMode.NONE，这里我们还是用的LazyThreadSafetyMode，只是值使用的是LazyThreadSafetyMode.SYNCHRONIZED。

class SingleTon4 {
    companion object {
        val instance by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            SingleTon4()
        }
    }
}

LazyThreadSafetyMode 是个枚举类，如下：

public enum class LazyThreadSafetyMode {

    /**
     * Locks are used to ensure that only a single thread can initialize the [Lazy] instance.
     */
    SYNCHRONIZED,

    /**
     * Initializer function can be called several times on concurrent access to uninitialized [Lazy] instance value,
     * but only the first returned value will be used as the value of [Lazy] instance.
     */
    PUBLICATION,

    /**
     * No locks are used to synchronize an access to the [Lazy] instance value; if the instance is accessed from multiple threads, its behavior is undefined.
     *
     * This mode should not be used unless the [Lazy] instance is guaranteed never to be initialized from more than one thread.
     */
    NONE,
}

5：静态内部类

kotlin中类似的写法如下：

class SingleTon5 {
    companion object {
        fun getInstance() = Holder.instance
    }

    private object Holder {
        val instance = SingleTon5()
    }
}