在 Java 语言中，static 关键字主要用于代表方法和属性是属于某个对象，而不是属于对象的实例。static 关键字也用于建立 Singleton (单例)，单例模式是很是常见的设计模式，它能够帮您建立某个对象的惟一实例，而且其它对象也能够访问和分享该实例。java
Kotlin 能够更加优雅地实现这种设计模式。您只需使用一个关键字: object，就能够实现单例。接下来的内容会告诉你们在 Java 和 Kotlin 中实现单例的区别，以及在 Kotlin 中如何在不使用 static 关键字的状况下实现单例，(其实就是经过 object 关键字实现的)，而后为你们详解使用 object 时底层的实现机制。设计模式
首先，咱们先聊聊这个应用场景的背景 —— 为何咱们须要一个单例呢？安全
什么是单例？
单例是一种设计模式，它保证一个类只有惟一一个实例，而且提供全局可访问该对象的接口。单例很是适合那些须要在应用的不一样地方共享的对象，以及初始化实例很是消耗资源的场景下使用。并发
Java 中的单例
要保证一个类只有一个实例，您须要控制对象的建立方式。要使类有且仅有一个实例，须要将构造方法定义为私有的 (private)，而且建立一个公共可访问的静态对象引用。与此同时，您通常不会在启动的时候建立单例，由于使用单例的对象在建立的时候很是耗费资源。要实现这个目的，须要提供一个静态方法，方法里会检查是否已经建立该对象。这个静态方法必须返回以前建立的实例，或者调用构造函数而后返回实例。异步
<!-- Copyright 2019 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->
public class Singleton{
private static Singleton INSTANCE;
private Singleton(){}
public static Singleton getInstance(){
if (INSTANCE == null){
INSTANCE = new Singleton();
}
return INSTANCE;
}
private int count = 0;
public int count(){ return count++; }
}
上面的代码看上去没什么，可是其实里面有个大问题: 这段代码没法保证线程安全。某一时刻当一个线程刚刚运行完 if 语句的时候有可能被挂起，而与此同时另一个线程调用该方法而且建立单例。而以前被挂起的线程会继续运行，并建立另一个实例。ide
<!-- Copyright 2019 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->
public class Singleton{
private static Singleton INSTANCE = new Singleton();
private Singleton(){}
public static Singleton getInstance(){
if (INSTANCE == null) { // 一次检查
synchronized (Singleton.class) {
if (INSTANCE == null) { // 二次检查
INSTANCE = new Singleton();
}
}
}
return INSTANCE;
}
private int count = 0;
public int count(){ return count++; }
}
要解决线程同步的问题，您可使用二次检查锁定。在二次检查锁定中，若是实例为空，则会经过 synchronized 关键字建立同步锁并，且对实例进行二次检查保证当前实例仍为空。若是此时实例仍为空，那么会建立单例。然而这还不够，单例对象还须要使用 volatile 关键字。volatile 关键字告诉编译器该变量可能会被并发运行的线程异步修改。函数
上述内容就会致使大量的模板代码，每次当您建立单例时就须要重复它们。对于这么一个简单的任务却使用了如此繁杂的代码，因此 Java 中建立单例时一般会使用 枚举。this
Kotlin 中的单例
那么咱们再来看看 Kotlin。Kotlin 中并无静态方法或者静态字段，那么咱们如何在 Kotlin 中建立单例呢？线程
实际上，能够经过 Android Studio/IntelliJ 来帮助咱们理解这一问题。当您将 Java 的单例代码转换为 Kotlin 代码时，全部的静态属性和方法就会被移动到 companion object 中。设计
<!-- Copyright 2019 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->
class Singleton private constructor() {
private var count = 0
fun count(): Int {
return count++
}
companion object {
private var INSTANCE: Singleton? =
Singleton()//二次检查
// Single Checked
val instance: Singleton?
get() {
if (INSTANCE == null) { //首次检查
synchronized(Singleton::class.java) {
if (INSTANCE == null) { //二次检查
INSTANCE =
Singleton()
}
}
}
return INSTANCE
}
}
}
通过转换的代码已经够实现咱们想要的效果，但其实可让代码更简洁。能够从 object 代码中去掉构造函数和 companion 关键字。文章后面会告诉你们 object 和 companion objects 之间的区别。
<!-- Copyright 2019 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->
object Singleton {
private var count: Int = 0
fun count() {
count++
}
}
当您想使用 count() 方法的时候，您能够经过 Singleton 对象调用该方法。在 Kotlin 中，object 是一种特殊的类，它只有一个实例。若是您建立类的时候使用的是 object 关键字而不是 class，Kotlin 编译器会将构造方法设置为私有的，而且为 object 类建立一个静态引用，同时在一个静态代码块里初始化该引用。
当静态字段第一次被访问的时候会调用静态代码块一次。即便没有 synchronized 关键字，JVM 处理静态代码块和处理同步代码块的方式相相似。当 Singleton 类进行初始化的时候，JVM 会从同步代码块中得到一个锁，如此一来，其它线程就没法访问它。当同步锁被释放的时候，就已经建立了 Singleton 实例，而且该静态代码块也不会再被运行。这样就保证了有且仅有一个 Singleton 实例，这就知足了单例的要求。这样一来，object 即保证了线程安全，也实现了首次访问的延迟建立。
咱们来看一下反编译的 Kotlin 字节码，深刻了解一下底层是如何实现的。
若是想查看一个 Kotlin 类的字节码，依次选择 Tools > Kotlin > Show Kotlin Bytecode。Kotlin 字节码显示之后，点击 Decompile 来查看反编译的 Java 代码。
<!-- Copyright 2019 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->
public final class Singleton {
private static int count;
public static final Singleton INSTANCE;
public final int getCount() {return count;}
public final void setCount(int var1) {count = var1;}
public final int count() {
int var1 = count++;
return var1;
}
private Singleton() {}
static {
Singleton var0 = new Singleton();
INSTANCE = var0;
}
}
然而 object 也有必定的限制。object 声明里不能包含构造函数，也就是说没法传参给它。即便它支持传参，因为静态代码块没法访问构造方法中的非静态参数，因此传入的参数也没法使用。
⚠️ 和其它静态方法同样，静态的初始化代码块只能访问一个类的静态属性。静态的代码块的调用要早于构造方法，因此静态代码块没法访问对象的属性或者传递给构造函数的参数。
companion object
companion object 和 object 相相似。companion object 经常在类中声明，而且它们的属性能够经过宿主类名进行访问。companion object 不须要定义名称。若是定义了 companion object 的名称，也能够经过名称来访问它的类成员。
<!-- Copyright 2019 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->
class SomeClass {
//…
companion object {
private var count: Int = 0
fun count() {
count++
}
}
}
class AnotherClass {
//…
companion object Counter {
private var count: Int = 0
fun count() {
count++
}
}
}
//不定义名称的场景
SomeClass.count()
//定义名称的场景
AnotherClass.Counter.count()
举个例子，这里咱们有两个类似的类定义，分别是带名称和不带名称的 companion object。能够经过 SomeClass 来调用 count() 方法，就像 SomeClass 的静态成员同样；或者也能够经过使用 Counter 来调用 count() 方法，就像 AnotherClass 的静态成员同样。
反编译 companion object 会获得一个带有私有构造函数的内联类。宿主类会经过一个合成构造方法来初始化一个内部类，这个内部类只有宿主类才可以访问。宿主类会保持一个 companion object 的公共引用，可用于其它类访问。
<!-- Copyright 2019 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->
public final class AnotherClass {
private static int count;
public static final AnotherClass.Counter Counter = new AnotherClass.Counter((DefaultConstructorMarker)null);
public static final class Counter {
public final void count() {
AnotherClass.count = AnotherClass.count + 1;
}
private Counter() { }
// $FF: synthetic method
public Counter(DefaultConstructorMarker $constructor_marker) {
this();
}
}
public static final class Companion {
public final void count() {
AnotherClass.count = AnotherClass.count + 1;
}
private Companion() {}
}
}
Object 表达式
到目前为止，咱们已经在声明对象的时候使用了 object 关键字，不过它也能够用于 object 表达式。看成为表达式使用时，object 关键字能够帮助您建立匿名对象和匿名内部类。
好比您须要一个临时对象来保持一些数据值时，能够当即声明对象并使用所需的数值进行初始化，以后再访问它们。
<!-- Copyright 2019 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->
val tempValues = object : {
var value = 2
var anotherValue = 3
var someOtherValue = 4
}
tempValues.value += tempValues.anotherValue
在所生成的代码中，这个操做会被转换为一个匿名的 Java 类，而且该对象会被标记为 <undefinedtype> 来保存匿名对象及其 getter 和 setter。
<!-- Copyright 2019 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->
<undefinedtype> tempValues = new Object() {
private int value = 2;
private int anotherValue = 3;
private int someOtherValue = 4;
// x,y,z 的 getter 和 setter
//...
};
object 关键字无需使用模板代码就能够建立匿名类。您可使用 object 表达式，而 Kotlin 编译器则会生成包裹类的声明来建立一个匿名类。
<!-- Copyright 2019 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->
//Kotlin 代码
val t1 = Thread(object : Runnable {
override fun run() {
// 逻辑代码
}
})
t1.start()
//反编译的 Java 代码
Thread t1 = new Thread((Runnable)(new Runnable() {
public void run() {
}
}));
t1.start();
object 关键字会帮助您使用更少的代码建立线程安全的单例、匿名对象和匿名类。经过 object 和 companion object， Kotlin 会生成所有所需的代码来实现相似 static 关键字的功能。此外，您还能够避免模板代码的困扰，仅经过使用 object 表达式来建立匿名对象和匿名类。