Android经典面试题之Kotlin中object关键字实现的是什么类型的单例模式？原理是什么？怎么实现双重检验锁单例模式？

本文首发于公众号“AntDream”，欢迎微信搜索“AntDream”或扫描文章底部二维码关注，和我一起每天进步一点点

object关键字实现单例模式

在 Kotlin 中实现单例模式非常简单，因为它提供了 object 关键字，可以用来创建单例对象。这里是一个简洁的示例和详细的解释：

定义单例对象

直接使用 object 关键字创建单例对象，这是最简单的方法。这个方法不需要编写额外的代码来确保该对象只有一个实例。

object Singleton {
    var someProperty: String = "default"

    fun doSomething() {
        println("Doing something with property: $someProperty")
    }
}

使用单例对象

可以像使用普通对象一样使用单例对象：

fun main() {
    // 修改属性
    Singleton.someProperty = "Hello, Kotlin"
    
    // 调用方法
    Singleton.doSomething()  // 输出: Doing something with property: Hello, Kotlin
}

object关键字原理

Kotlin中的object关键字用于声明一个单例对象。这个对象在第一次访问时会被实例化，之后所有对该对象的引用都指向同一个实例。

字节码

public final class Singleton {
   @NotNull
   private static String someProperty;
   @NotNull
   public static final Singleton INSTANCE;

   @NotNull
   public final String getSomeProperty() {
      return someProperty;
   }

   public final void setSomeProperty(@NotNull String var1) {
      Intrinsics.checkNotNullParameter(var1, "<set-?>");
      someProperty = var1;
   }

   public final void doSomething() {
      String var1 = "Doing something with property: " + someProperty;
      System.out.println(var1);
   }

   private Singleton() {
   }

   static {
      Singleton var0 = new Singleton();
      INSTANCE = var0;
      someProperty = "default";
   }
}

其实现原理可以通过以下几个步骤进行解析：

1、 Class 静态初始化块：

• 在Kotlin的单例对象被第一次引用时，它会触发一个静态初始化块来创建这个对象的实例。这类似于Java中的静态初始化块。

2、 线程安全：

• object关键字生成的单例是线程安全的。这是通过JVM的类加载机制保证的，JVM会确保类的静态初始化块在多线程环境中只会被执行一次。

3、 饿汉式单例：

• 从严格意义上来说，object关键字生成的单例更接近于“饿汉式单例”模式，因为该实例会在类加载时被创建并初始化。

Kotlin中的懒汉式单例

懒汉式单例是一种在第一次需要时才创建实例的单例模式，搭配Kotlin的lazy委托可以简单实现：

class LazySingleton private constructor() {
    companion object {
        val instance: LazySingleton by lazy { LazySingleton() }
    }
}

Kotlin中的双重检验锁单例模式

如果你需要传递参数来初始化单例，可以考虑双重检验锁单例模式

双重检验锁单例模式可以确保在多线程环境中的高效及线程安全，虽然在Kotlin中不太常用，但也可以通过@Volatile 关键字以及synchronized关键字实现：

class SingletonWithParams private constructor(val someProperty: String) {
    
    init {
        println("SingletonWithParams is initialized with someProperty: $someProperty")
    }

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

        fun getInstance(property: String): SingletonWithParams {
            return instance ?: synchronized(this) {
                instance ?: SingletonWithParams(property).also { instance = it }
            }
        }
    }

    fun doSomething() {
        println("Doing something with property: $someProperty")
    }
}

使用带参数的单例

fun main() {
    val singleton = SingletonWithParams.getInstance("Hello, Kotlin with Params")
    singleton.doSomething()  // 输出: Doing something with property: Hello, Kotlin with Params

    // 尝试获取另一个实例
    val anotherSingleton = SingletonWithParams.getInstance("Another Value")
    anotherSingleton.doSomething()  // 输出: Doing something with property: Hello, Kotlin with Params
}

在上面的例子中，通过 companion object 提供一个静态方法 getInstance 来获取单例实例，并且通过 @Volatile 和 synchronized 确保线程安全。

总结

Kotlin 提供了多种方便且简洁的方法来实现单例模式：

1、 Object 关键字：最简单的方式，适用于没有参数的单例。
2、 伴生对象以及自定义静态方法：适用于需要初始化参数或自定义初始化逻辑的单例。也就是Java中的DCL单例

根据实际需求选择合适的方法，可以让你的代码更加简洁和有效。

---

欢迎关注我的公众号AntDream查看更多精彩文章！