阅读 6758

聊聊Kotlin单例,从object单例,到带参数单例,论如何优雅的封装!

一. 序

单例模式是我们在日常编程中,比较常用的设计模式。一个好的单例,必然需要满足唯一性和线程安全性。而 Java 中,关于单例的文章讲解已经很完善了,单例模式已经成为一种编程范式。

在谷歌强推 Kotlin 的今天,不少人使用 Kotlin 时,还带着 Java 的编程思维,并没有有效的利用 Kotlin 的一些特性。如果还用 Java 的编程思想来写 Kotlin 的单例,会有种四不像的感觉。

在 Kotlin 里,想要实现单例模式,只需要将类增加 object 关键字即可,这就是一个线程安全的单例模式,很方便。

但是这存在一个问题,object class 无法实现构造方法,也就是我们无法在初始化的时候,从外部传递一些参数来让这个单例类初始化。

本文就来聊聊 Kotlin 下的单例模式的实现,以及如何优雅的构造一个带参数的单例模式。

二. Kotlin 的单例

2.1 object class 的单例

虽然无法在构造的时候,从外部传递参数,但是 object 关键字依然是 Kotlin 下,最常用的构造单例方法,我们先来了解它的特性。

object 关键字使用起来非常简单,只需要直接作用在 class 上就好。

object SomeSingleton{
  fun sayHi(){}
}
复制代码

这就是在 Kotlin 下,最简单的单例模式,如果想要有一些初始化的动作,可以放在 init 块中。

object SomeSingleton{
  init{
      // init
  }
  fun sayHi(){}
}
复制代码

使用方法也非常简单,需要注意的是,在 Kotlin 中调用和 Java 调用存在一些差异。

// Kotlin Language
SomeSingleton.sayHi()

// Java  Language
SomeSingleton.INSTANCE.sayHi()
复制代码

我们知道,Kotlin 和 Java 是可以无缝互通的,而 Kotlin 最终编译的字节码,其实也是可以转成类 Java 的代码。

那我们继续看看 Kotlin 的 object 关键字后,在 Java 中的表现到底如何。通过这种转码的分析,可以便于我们理解 Kotlin 的特性。

借助 AS 的 Tools → Kotlin → Show Kotlin Bytecode,就可以查看 Kotlin 文件的字节码,再点击 Decompile 按钮,就可以将字节码转成 Java 代码。

有对比就清晰了,Kotlin 的 object 关键字,在 Java 表现的特点如下:

  1. 类用 final 标记,标识不可变性。

  2. 内部声明一个 static final 的当前类的对象 INSATNCE。

  3. 在静态代码块中,进行 INSTANCE 对象的初始化。

可以看到,在 Kotlin 的 object 中,是使用类的初始化锁来保证线程安全的。

那什么是类的初始化锁?

简单来说, JVM 在类的初始化阶段(即在 Class 被加载后,且被线程使用之前),会执行类的初始化,在初始化期间,JVM 会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化,避免多线程调用时,引发线程安全的问题。

上图很清晰的表明了类的初始化锁的工作流程。

而 Kotlin 中的 object 关键字,就是利用类的初始化锁来保证线程安全的,在我们不需要为单例的初始化传递外部参数的场景下,可以放心使用。

那可能有人担心另一个问题,类加载的时候就初始化构造单例对象,是不是对资源的利用不友好?

这一点问题不大,虚拟机在运行程序的时候,并不是在启动时就将所有的类,都加载进来并初始化完成,而是一种按需加载的策略,在真正使用它的时候,才会初始化。

例如:new Class、调用静态方法、反射、调用 Class.forName() 方法等。这一点可以通过本文介绍的单例实现,在 init 块中输出 Log,看看 Log 何时输出来验证,相关资料很多,就不多说了。

也就是说,通常只有在你真实使用这个类时,它才会真的被虚拟机初始化。当然,不同虚拟机的实现方式不同,这并不是强制的,但是大多数为了性能都会准守此规则。

2.2 传参数的单例

无参单例可以用 object 关键字,但如果想通过一些外部参数初始化单例呢?Kotlin 的 object 是不能有任何构造函数的,所以也无法传递任何参数。

带参单例在 Android 中也是有一些使用场景的,例如 Android 中的 LocalBroadcastManager,就是一个带参的单例模式。

LocalBroadcastManager.getInstance(context).sendBroadcast(intent)
复制代码

那换个思路想想,在 Java 中,带参数的单例如何实现?通常都会用双重检查锁(Double Checked Locking) + volatile 关键字来解决。

public class DoubleCheckSingleton {
    private volatile static DoubleCheckSingleton sInstance;
    private DoubleCheckSingleton(Context ctx) {
          // init
    }
    public static DoubleCheckSingleton getInstance(Context ctx) {
        if (sInstance == null) {
            synchronized (DoubleCheckSingleton.class) {
                if (sInstance == null) {
                    sInstance = new DoubleCheckSingleton(ctx);
                }
            }
        }
        return sInstance;
    }
}
复制代码

加上 volatile 是为了可见性和禁止重排序,这样就可以保证把参数传递进去的同时,确保线程安全。

不过在 Kotlin 中是没有 volatile 关键字的,取而代之的是 @Volatile 注解,同时需要配合 Kotlin 的伴生对象进行单例模式的构建。

伴生对象可以简单的使用类名作为限定符来调用其方法,类似 Java 中的静态方法。

final class SomeSingleton(context: Context) {
    private val mContext: Context = context
    companion object {
        @Volatile
        private var instance: SomeSingleton? = null
        fun getInstance(context: Context): SomeSingleton {
            val i = instance
            if (i != null) {
                return i
            }

            return synchronized(this) {
                val i2 = instance
                if (i2 != null) {
                    i2
                } else {
                    val created = SomeSingleton(context)
                    instance = created
                    created
                }
            }
        }
    }
}
复制代码

这段代码是直接借鉴的 Kotlin 的 lazy(),lazy 在默认情况下的实现是 SynchronizedLazyImpl,从类名上就能看出来,它使用 synchroinzed 来保证线程安全。

用这样的方式,就可以实现一个可以传参数去构造的单例模式。

2.3 封装一个带参单例

支持传参的单例,我们实现了。但为了实现这个单例,写了 20+ 行代码。每次写单例都要把这一堆代码复制一遍,还挺麻烦,为了使用方便,还可以将其再封装一下。

open class SingletonHolder<out T, in A>(creator: (A) -> T) {
    private var creator: ((A) -> T)? = creator
    @Volatile
    private var instance: T? = null

    fun getInstance(arg: A): T {
        val i = instance
        if (i != null) {
            return i
        }

        return synchronized(this) {
            val i2 = instance
            if (i2 != null) {
                i2
            } else {
                val created = creator!!(arg)
                instance = created
                creator = null
                created
            }
        }
    }
}
复制代码

用一个支持继承的 open class 加上泛型就可以简单的将其进行封装,此封装方式支持一个参数的构造方法,有需要可以继续扩展或者封装。

class SomeSingleton private constructor(context: Context) {
    init {
        // Init using context argument
        context.getString(R.string.app_name)
    }

    companion object : SingletonHolder<SomeSingleton, Context>(::SomeSingleton)
}
复制代码

封装成 SingletonHolder 类之后,再想使用单例,关键代码一行就搞定了。

2.4 使用 lazy

前面在介绍带参单例的时候,也提到了lazy(),它是 Kotlin 的一种标准委托,可以接受一个 lambda 并返回一个实例的函数。

如果我们想要延迟初始化,可以使用 lazy() 这个代理来实现,它会在第一次调用get() 方法时,执行 lazy() 的 lambda 表达式并记录结果,之后再调用 get()就只会返回之前记录的结果,非常适合延迟初始化的场景。

class SomeSingleton{
    companion object {
        val instance: SomeSingleton by lazy { SomeSingleton() }
    }
}
复制代码

lazy() 默认情况下,内部就是依赖同步锁(synchronized)来实现的,所以它也是线程安全的。

但是正如我前面提到的,类本身也是按需加载的,调用它的下一步肯定是也需要使用它,所以只要我们正确的使用单例模式,其实没必要使用 lazy(),这里仅做一个介绍,大家知道一下就好了。

三. 小结时刻

本文介绍了在 Kotlin 下,实现单例模式的一些代码技巧,希望对大家有所帮助。最后再简单总结一下。

  1. 无参单例模式,直接使用 Kotlin 的 object 即可,它是依赖类的初始化锁来保证线程安全。

  2. 带参单例模式,可以使用双重检查锁 + @Volatile 来实现,如果嫌麻烦还可以封装成 SingletonHolder。

  3. lazy() 委托确实可以实现延迟加载,但是在单例模式的场景下,不如直接用object 方便。

文章分类
Android
文章标签