Kotlin——單例模式

最近在寫項目的同時也用到了單例模式，kotlin的單例還不是很會寫，現(xiàn)在就總結(jié)下java寫法對應(yīng)的kotlin是如何寫的。

  • 餓漢式
  • 懶漢式
  • 線程安全的懶漢式
  • 雙重校驗鎖式
  • 靜態(tài)內(nèi)部類式

單例模式的基本思想就是在程序運行過程中不會重復(fù)創(chuàng)建要使用的對象，有且只創(chuàng)建一次。這就需要用到kotlin中的object和companion object(伴生對象)，因為他們可以充當java下的static。

餓漢式實現(xiàn)

  • java
public class Singleton{
    private static Singleton instance = new Singleton();
    
    private Singleton(){}
    
    public static Singleton getInstance(){
        return instance;
    }
}
  • kotlin
object Singleton

可以看到kotlin的餓漢單例實現(xiàn)只有一行代碼。用到了object關(guān)鍵字，object關(guān)鍵字定義一個類并同時創(chuàng)建一個實例(就是一個對象)。它其中的一種使用場景就是對象聲明定義單例。

與類一樣，一個對象聲明也可以包含屬性、方法、初始化語句塊等的聲明。唯一不允許的就是構(gòu)造方法(包括主構(gòu)造方法和從構(gòu)造方法)。與普通類的實例不同，對象聲明在定義的時候就立即創(chuàng)建了，不需要在代碼的其他地方調(diào)用構(gòu)造方法。為對象聲明定義一個構(gòu)造方法是沒有意義的。

與變量一樣，對象聲明允許使用對象名.字符的方法來調(diào)用方法和訪問屬性。

下面是kotlin餓漢式編譯成java代碼后的代碼，幫助我們理解。

public final class Singleton {
   public static final Singleton INSTANCE;

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

可以看到編譯后的Java代碼，直接將初始化對象的代碼放在了靜態(tài)代碼塊中。

餓漢式實現(xiàn)

  • java
public class Singleton{
    private static Singleton instance;
    private Singleton(){}
    public static Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}
  • kotlin
class Singleton private constructor(){
    companion object{
        private var instance:Singleton? = null
            get(){
                if(field == null){
                    field = Singleton()
                }
                return field
            }
        fun get():Singleton{
            return instance!!//!!表示當前對象不為空的情況下執(zhí)行
        }
    }
}

這里使用了伴生對象，在其內(nèi)部創(chuàng)建對象并調(diào)用get()方法返回。

看看kotlin代碼編譯成java代碼的樣子：

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

   private Singleton() {
   }

   // $FF: synthetic method
   public Singleton(DefaultConstructorMarker $constructor_marker) {
      this();
   }

   public static final class Companion {
    //創(chuàng)建單例對象
      private final Singleton getInstance() {
         if (Singleton.instance == null) {
            Singleton.instance = new Singleton((DefaultConstructorMarker)null);
         }

         return Singleton.instance;
      }

      private final void setInstance(Singleton var1) {
         Singleton.instance = var1;
      }

      @NotNull
      public final Singleton get() {
         Singleton var10000 = ((Singleton.Companion)this).getInstance();
         if (var10000 == null) {
            Intrinsics.throwNpe();
         }

         return var10000;
      }

      private Companion() {
      }

      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

線程安全的懶漢式實現(xiàn)

  • java
public class Singleton{
    private static Singleton instance;
    private Singleton(){}
    public static synchronized Singleton getInstance(){//使用同步鎖
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}
  • kotlin
class Singleton private constructor(){
    companion object{
        private var instance: Singleton? = null
            get(){
                if(field == null){
                    field = Singleton()
                }
                return field
            }
        @Synchronized
        fun get(): Singleton{
            return instance!!
        }
    }
}

在kotlin中如果需要將方法聲明為同步，需要添加 @Synchronized注解。

康康編譯為java代碼的樣子：

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

   private Singleton() {
   }

   // $FF: synthetic method
   public Singleton(DefaultConstructorMarker $constructor_marker) {
      this();
   }

   public static final class Companion {
      private final Singleton getInstance() {
         if (Singleton.instance == null) {
            Singleton.instance = new Singleton((DefaultConstructorMarker)null);
         }

         return Singleton.instance;
      }

      private final void setInstance(Singleton var1) {
         Singleton.instance = var1;
      }
    
    //get()方法 使用了同步鎖
      @NotNull
      public final synchronized Singleton get() {
         Singleton var10000 = ((Singleton.Companion)this).getInstance();
         if (var10000 == null) {
            Intrinsics.throwNpe();
         }

         return var10000;
      }

      private Companion() {
      }

      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

雙重校驗鎖式實現(xiàn)

  • java
public class Singleton{
    private volatile static Singleton instance;
    private Singleton(){}
    public static Singleton getInstance(){
        if(instance == null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

雙重鎖模式應(yīng)該是日常開發(fā)中比較常用的一種形式了，現(xiàn)在復(fù)習下其中的知識點。

  1. 第一次判斷singleton是否為null

第一次判斷是在synchronized同步代碼塊外進行判斷，由于單例模式只會創(chuàng)建一個實例，并通過getInstance方法返回singleton對象，所以第一次判斷是為了在singleton對象已經(jīng)創(chuàng)建的情況下，避免進入同步代碼塊，提升效率。

  1. 第二次判斷singleton是否為null

第二次是為了避免以下情況的發(fā)生。

(1)假設(shè)：線程A已經(jīng)經(jīng)過第一次判斷，判斷singleton=null,準備進入同步代碼塊。

(2)此時，線程B獲得時間片，由于線程A并沒有創(chuàng)建實例，所以判斷singleton仍為null,所以線程B創(chuàng)建了實例singleton。

(3)此時，線程A再次獲得時間片，由于剛經(jīng)過第一次判斷singleton為null(不會重復(fù)判斷)，進入同步代碼快，這個時候如果不加入第二次判斷的話，線程A又會創(chuàng)建一個實例singleton,就不滿足單例模式的需求，所以第二次判斷是很有必要的。

  1. 加volatile關(guān)鍵字的原因

第一，volatile可以保證可見性和原子性，同時保證JVM對指令不會進行重排列。

第二，對象的創(chuàng)建不是一步完成的，是一個符合操作，需要三個指令。

singleton = new Singleton() 為例子

指令1：獲取singleton對象的內(nèi)存地址

指令2：初始化singleton對象

指令3：將這塊內(nèi)存地址指向引用變量singleton

由于volatile禁止JVM對指令進行重排序，所以創(chuàng)建對象的過程仍然或按照指令1-2-3有序的執(zhí)行。

若沒有volatile關(guān)鍵字，在多線程的情況下，假設(shè)線程A正常創(chuàng)建一個實例，那么指定執(zhí)行的順序可能2-1-3，當執(zhí)行到指令1的時候，線程B執(zhí)行g(shù)etInstance方法，獲取到的，可能是對象的一部分，或者是不正確的對象，程序可能就會報異常信息。

  • kotlin
class SingletonDemo private constructor() {
    companion object {
        val instance: SingletonDemo by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
        SingletonDemo() }
    }
}

看到這種寫法，哇，真的比java少了很多代碼，但是越簡單的代碼就會包含越多的信息點，我們需要理解為什么要這樣做。這里用到了by lazy(),kotlin的委托屬性的延遲屬性。

延遲屬性：其值只在首次訪問時計算。委托屬性具體可參考官方文檔。

lazy函數(shù)返回一個對象，該對象具有一個名為getValue且簽名正確的方法，因此可以把它與by關(guān)鍵字一起使用來創(chuàng)建一個委托屬性。默認情況下，lazy函數(shù)是線程安全的，如果需要可以設(shè)置其它選項來高速它要使用哪個鎖，或者完全避開同步，如果該類永遠不會在多線程環(huán)境中使用。

下面來看看源碼加深理解：

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():

internal object UNINITIALIZED_VALUE

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() {
            //判斷是否已經(jīng)初始化過，如果初始化過直接返回，不在調(diào)用高級函數(shù)內(nèi)部邏輯
            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!!()//調(diào)用高級函數(shù)獲取其返回值
                    _value = typedValue//將返回值賦值給_value,用于下次判斷時，直接返回高級函數(shù)的返回值
                    initializer = null
                    typedValue
                }
            }
        }
    //省略部分代碼
}

靜態(tài)內(nèi)部類式實現(xiàn)

  • java
public class Singleton{
    private static class SingletonHolder{
        private static Singleton instance = new Singleton();
    }
    
    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}
  • kotlin
class Singleton private constructor(){
    companion object{
        val instance = SingletonHolder.holder
    }
    
    private object SingletonHolder{
        val holder = Singleton()
    }
}

注意

對象聲明(object)不是一個表達式，不能用在賦值語句的右邊。

對象聲明的初始化是線程安全的并且在首次訪問時進行。

對象聲明不能在局部作用域(即不能直接嵌套在函數(shù)內(nèi)部)，但是他們可以嵌套到其他對象聲明或非內(nèi)部類中。

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

友情鏈接更多精彩內(nèi)容