4-singleton-implementations.md

Kotlin中的单例实现

单例模式需要保证类只存在一个实例, 通常用来节约资源或者保证一致的状态.

单例的实现首先主要是通过私有构造, 保证了类不能在外部被随意实例化.

在Java中实现单例会利用静态方法, 来返回唯一的对象, Kotlin中没有静态了, 写法是什么样呢?

Java中的单例实现

我们先来回忆一下Java中的几种实现.

方法1:

/**
 * 单例实现方法1:
 * <p>
 * 缺点: 多线程的情况存在问题, 可能会创建出多个对象.
 */
public class Singleton1 {

    private static Singleton1 instance;

    private Singleton1() {
    }

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

这种方法是最简单的, 什么也没考虑, 就需要实例的时候检查是否已经被创建, 如果没有就创建一个实例, 然后返回这个实例.

在多线程使用的时候, 有可能会创建多个实例, 即单例模式本身无法保证.

方法2:

/**
 * 单例实现方法2: 将实例化操作提前.
 * 在静态初始化的时候创建实例, 保证线程安全.
 * <p>
 * 缺点: 如果从来未使用过, 初始化是一种浪费.
 */
public class Singleton2 {

    private static Singleton2 instance = new Singleton2();

    private Singleton2() {
    }

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

这种实现方式解决了多线程的问题, 采用的方法是在静态初始化的时候就把实例创建好. 缺点就是如果我从来也没有用到过这个实例, 那么就白创建了.

方法3:

/**
 * 单例实现方法3: 用synchronized关键字保证线程安全.
 * <p>
 * 缺点: 会降低性能. 即便对象已经被创建, 仍然多次进行同步.
 */
public class Singleton3 {

    private static Singleton3 instance;

    private Singleton3() {
    }

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

用关键字保证了多线程情况下也不会创建多个. 但是创建之后仍然每次都会同步, 有效率问题.

方法4:

/**
 * 单例实现方法4: 双重检查加锁.
 * 只有实例尚未创建才会进行同步.
 * <p>
 * 缺点: 写起来复杂.
 */
public class Singleton4 {

    private volatile static Singleton4 instance; //volatile关键字保证可见性, 字段被访问时用的都是共享值, 而不是缓存拷贝

    private Singleton4() {
    }

    public static Singleton4 getInstance() {
        if (instance == null) {
            synchronized (Singleton4.class) {
                if (instance == null) { //进入块之后会再检查一次
                    instance = new Singleton4();
                }
            }
        }
        return instance;
    }
}

这是一个双重检查的锁, 在多线程下保证单例, 同时避免了上面说的效率问题.

Kotlin单例实现1: Object声明

怎么在Kotlin中实现一个单例呢? 最简单的方法就是用对象声明:

object SingletonOne {
    
}

这种实现方法的本质是什么呢? 这里介绍IDE(Android Studio或Intellij)的一个工具: Tools -> Kotlin -> Show Kotlin Bytecode, 显示Kotlin字节码之后, 该窗口左上角还有一个Decompile按钮, 点击之后显示:

public final class SingletonOne {
   public static final SingletonOne INSTANCE;

   private SingletonOne() {
   }

   static {
      SingletonOne var0 = new SingletonOne();
      INSTANCE = var0;
   }
}

怎样, 反编译后发现这不就是上面的第二种实现方式吗, 只不过这里INSTANCE域是public的, 所以没有提供getInstance方法.

使用这样的单例时, 直接用类名就可以访问其方法:

object SingletonOneWithMethod {
    private const val age = 20
    fun foo() {
        println(this.hashCode().toString() + " with age $age")
    }
}

fun main() {
    SingletonOneWithMethod.foo()
}

Kotlin单例实现2: class + companion object

单例实现的第二种方法:

class SingletonTwo private constructor() {
    companion object {
        private var instance: SingletonTwo? = null

        fun getInstance() =
            instance ?: SingletonTwo().also { instance = it }
    }
}

用的是class, 把构造声明为私有. 其中getInstance()方法写得稍微有点炫酷哈, 其实它要做的事情就是检查是否为null, 如果为null则创建实例, 不为null则直接返回. 所以它对应的是Java实现1.

这种实现方法比上一种好在哪里呢? 首先, 它是第一次用到的时候才初始化的, 如果没用到就永远也不会初始化. 其次, 它可以在构造中传入参数.

class SingletonTwoWithArguments private constructor(
    private val name: String,
    private val age: Int
) {
    companion object {
        private var instance: SingletonTwoWithArguments? = null

        fun getInstance(name: String, age: Int) =
            instance ?: SingletonTwoWithArguments(name, age).also { instance = it }
    }

    override fun toString(): String {
        return "SingletonTwoWithArguments${hashCode()}(name='$name', age=$age)"
    }
}

fun main() {
    val instance1 = SingletonTwoWithArguments.getInstance("hello", 1)
    println(instance1)
    val instance2 = SingletonTwoWithArguments.getInstance("world", 2)
    println(instance2)
    val instance3 = SingletonTwoWithArguments.getInstance("ddmeng", 30)
    println(instance3)
}

这里的输出结果永远是第一个创建的实例.即"hello, 1".

但是这和Java的同等实现1一样, 它在多线程情况下有可能会创建多个实例.

Kotlin单例实现3: 为了线程安全, 加同步

这是对上一个实现的改进, 把方法改为同步的, 对应于Java的实现3.

class SingletonThree private constructor() {
    companion object {
        private var instance: SingletonThree? = null

        @Synchronized
        fun getInstance() =
            instance ?: SingletonThree().also { instance = it }
    }
}

缺点也是一样的, 实例已经创建后还是会同步, 所以有效率问题.

Kotlin单例实现4: 双重检查加锁

再对上面的实现做个改进:

class SingletonFour private constructor() {
    companion object {
        @Volatile
        private var instance: SingletonFour? = null

        fun getInstance() =
            instance ?: synchronized(this) {
                instance ?: SingletonFour().also { instance = it }
            }
    }
}

这里做了double check, 只有实例为空时才进入同步块, 提升了效率. 注意这里不要忘了字段需要是@Volatile的.

这种实现可以参见Google Sample中的一个实例: sunflower: GardenPlantingRepositor. 双重检查加锁, 带一个构造参数.

Kotlin单例实现5: lazy

这里用到一个Kotlin的特性: lazy properties.

lazy()接收一个lambda作为初始化方法, 只有第一次访问的时候会被调用, 然后结果就被保存下来了, 之后的访问会直接返回这个结果. 默认的线程安全模式是LazyThreadSafetyMode.SYNCHRONIZED.

使用lazy来实现单例:

class SingletonFive private constructor() {
    companion object {
        val instance: SingletonFive by lazy {
            println("lazy body")
            SingletonFive()
        }
    }
}

fun main() {
    val instance1 = SingletonFive.instance
    println(instance1)
    val instance2 = SingletonFive.instance
    println(instance2)
    val instance3 = SingletonFive.instance
    println(instance3)
}

从执行结果可以看出"lazy body"只被输出了一次, 并且实例是同一个.

Kotlin单例实现6: isInitialized

声明保存实例的变量是lateinit的, 判断是否已经初始化用: isInitialized.

class SingletonSix private constructor() {
    companion object {
        private lateinit var instance: SingletonSix
        fun getInstance(): SingletonSix {
            synchronized(this) {
                if (!::instance.isInitialized) {
                    instance = SingletonSix()
                }
            }
            return instance
        }
    }
}

这个实现类似于实现3. 所以要进一步改成双重加锁(实现4)也是可以的.

Bonus: 用Dagger来实现单例

Dagger是Android开发中不可或缺的一个好工具.

仔细想想在工作中虽然用了很多单例, 但很少是自己实现的, 多数是利用Dagger.

Dagger的使用这里不展开介绍了, 只说说单例相关的.

Dagger中的@Singleton是一个常用的scope注解. 它的用法:

• 标记在component上作为一个scope标记.
• 标记在依赖上(类名或module中的provide方法上), 说明这个依赖在该scope下是一个单例.

看上去只用简单的两个注解, dagger会帮我们做完其他的事情, 保证只有一个实例.

通常我会把我的主component用@Singleton标记, 然后把所有全局单例用@Singleton标记.

除此之外我们还可以定义其他特定scope下的单例, 比如给Activity的component定义一个scope, 让一些依赖成为这个scope意义下的单例.

举个例子: 比如我有一个类叫PreferencesUtils, 在构造上标记@Inject把它加入graph, 再加上@Singleton让它成为单例:

@Singleton
class PreferencesUtils @Inject constructor(appContext: Application)

在生成的DaggerXXXXComponent类的initialize发面里面可以看到:

this.preferencesUtilsProvider = DoubleCheck.provider(PreferencesUtils_Factory.create(applicationProvider));

如果类上没有加@Singleton注解, 那么这行就只是:

this.preferencesUtilsProvider = PreferencesUtils_Factory.create(applicationProvider);

从DoubleCheck这个类中可以看到, Dagger内部的单例实现是一个双重检查加锁:

public final class DoubleCheck<T> implements Provider<T>, Lazy<T> {
  private static final Object UNINITIALIZED = new Object();

  private volatile Provider<T> provider;
  private volatile Object instance = UNINITIALIZED;

  private DoubleCheck(Provider<T> provider) {
    assert provider != null;
    this.provider = provider;
  }

  @SuppressWarnings("unchecked") // cast only happens when result comes from the provider
  @Override
  public T get() {
    Object result = instance;
    if (result == UNINITIALIZED) {
      synchronized (this) {
        result = instance;
        if (result == UNINITIALIZED) {
          result = provider.get();
          instance = reentrantCheck(instance, result);
          /* Null out the reference to the provider. We are never going to need it again, so we
           * can make it eligible for GC. */
          provider = null;
        }
      }
    }
    return (T) result;
  }
  // ...
}