Kotlin 单例模式

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/mengks1987/article/details/84141049

Kotlin 中创建单例模式模式有如下几种模式：

1、object

object Single1 {
    fun add(){}
}

用object做关键字就是一个单例，我们看下对应的Java代码：

public final class Single1 {
   public static final Single1 INSTANCE;

   public final void add() {
   }

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

我们发现这就是典型的饿汉式单例，在类加载的时候就进行了初始化，没有懒加载。

2、双验证方式

双验证的单例模式：

class SingletonJava private constructor() {
    companion object {
        @Volatile
        private var mInstance: SingletonJava? = null

        val instance: SingletonJava?
            get() {
                if (mInstance == null) {
                    synchronized(SingletonJava::class.java) {
                        if (mInstance == null) {
                            mInstance = SingletonJava()
                        }
                    }
                }
                return mInstance
            }
    }
}

由于Kotlin中没有 static关键字，所以静态方法放在companion object{}中，
我们看下这段Kotlin代码转为Java：

public final class SingletonJava {
   private static volatile SingletonJava mInstance;
   public static final SingletonJava.Companion Companion = new SingletonJava.Companion((DefaultConstructorMarker)null);

   public final void add() {
   }

   private SingletonJava() {
   }

   // $FF: synthetic method
   public SingletonJava(DefaultConstructorMarker $constructor_marker) {
      this();
   }
   public static final class Companion {
      @Nullable
      public final SingletonJava getInstance() {
         if (SingletonJava.mInstance == null) {
            Class var1 = SingletonJava.class;
            synchronized(var1){}

            try {
               if (SingletonJava.mInstance == null) {
                  SingletonJava.mInstance = new SingletonJava((DefaultConstructorMarker)null);
               }

               Unit var3 = Unit.INSTANCE;
            } finally {
               ;
            }
         }

         return SingletonJava.mInstance;
      }

      private Companion() {
      }

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

3、静态内部类

静态内部类方式实现的单例模式

class Singleton1 private constructor() {
    private object SingletonInstance {
         val INSTANCE = Singleton1()
    }

    companion object {
        val instance: Singleton1
            get() = SingletonInstance.INSTANCE
    }
}

总结：
1、第一种方式（object）写法简单但没有懒加载机制。
2、第2、3中方式是java中我们常用的单例模式，推荐使用，但更推荐使用第3种方式，第2种方式每次获取实例的时候会判断实例是否存在，仍然需要一些开销。
3、其实单例模式只要做到懒加载、线程安全、一个实例 这3点就ok了