在 Java 语言中，static 关键字主要用于表明方法和属性是属于某个对象，而不是属于对象的实例。static 关键字也用于创建 Singleton (单例)，单例模式是非常常见的设计模式，它可以帮您创建某个对象的唯一实例，并且其它对象也可以访问和分享该实例。

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 语句的时候有可能被挂起，而与此同时另外一个线程调用该方法并且创建单例。而之前被挂起的线程会继续运行，并创建另外一个实例。

<!-- 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 中创建单例时通常会使用 枚举。

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 表达式来创建匿名对象和匿名类。