kotlin 单例四种写法

1. 饿汉式

object Singleton {
}

反编译成java

public final class Singleton {
   public static final Singleton INSTANCE;

   private Singleton() {
   }

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

静态变量，static块中初始化

2. 懒汉式

class Singleton {
    val singleton: Singleton by lazy {
        Singleton()
    }
}

by lazy默认实现是线程安全的

public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

public actual fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> =
    when (mode) {
        LazyThreadSafetyMode.SYNCHRONIZED -> SynchronizedLazyImpl(initializer)
        LazyThreadSafetyMode.PUBLICATION -> SafePublicationLazyImpl(initializer)
        LazyThreadSafetyMode.NONE -> UnsafeLazyImpl(initializer)
    }

SynchronizedLazyImpl

private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {
    private var initializer: (() -> T)? = initializer
    @Volatile private var _value: Any? = UNINITIALIZED_VALUE
    // final field is required to enable safe publication of constructed instance
    private val lock = lock ?: this

    override val value: T
        get() {
            val _v1 = _value
            if (_v1 !== UNINITIALIZED_VALUE) {
                @Suppress("UNCHECKED_CAST")
                return _v1 as T
            }

            return synchronized(lock) {
                val _v2 = _value
                if (_v2 !== UNINITIALIZED_VALUE) {
                    @Suppress("UNCHECKED_CAST") (_v2 as T)
                } else {
                    val typedValue = initializer!!()
                    _value = typedValue
                    initializer = null
                    typedValue
                }
            }
        }

    override fun isInitialized(): Boolean = _value !== UNINITIALIZED_VALUE

    override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."

    private fun writeReplace(): Any = InitializedLazyImpl(value)
}

熟悉的volatile和synchronized

3. 静态内部类

class Singleton {
    companion object {
        fun getInstance() = Helper.instance
    }

    private object Helper {
        val instance = Singleton()
    }
}

反编译成java

public final class Singleton {
   public static final Singleton.Companion Companion = new Singleton.Companion((DefaultConstructorMarker)null);

   private static final class Helper {
      @NotNull
      private static final Singleton instance;
      public static final Singleton.Helper INSTANCE;

      @NotNull
      public final Singleton getInstance() {
         return instance;
      }

      static {
         Singleton.Helper var0 = new Singleton.Helper();
         INSTANCE = var0;
         instance = new Singleton();
      }
   }

   public static final class Companion {
      @NotNull
      public final Singleton getInstance() {
         return Singleton.Helper.INSTANCE.getInstance();
      }

      private Companion() {
      }

      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

Helper静态内部类初始化了单例，Companion提供getInstance方法。

4. 枚举

enum class Singleton {
    INSTANCE
}