object

单例对象的声明：

object  Model{
    var temp = "1"
    val temp2 = "2"
    const val temp3 = "3"
}

抛出疑问：使用object修饰的类，是哪种类型的单例模式

这里我们先回顾一下java六种单例模式

1. 饿汉式

public class HungryMan {

    private HungryMan(){}

    private static HungryMan hungryMan = new HungryMan();

    public static HungryMan getInstance(){
        return hungryMan;
    }
}

优点：简单方便，线程安全

缺点：无论是否用到，都会进行实例化，而且在类加载时就会实例化

2. 懒汉式

public class LazyMan {

    private static LazyMan lazyMan = null;

    private LazyMan() {
    }

    public static LazyMan getInstatce() {
        if (lazyMan == null) {
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }
}

优点：只有在使用时才会生成对象，能够减少内存开销

缺点：线程不安全，只能在单线程中使用，多个线程访问时，会产生多个对象，

3.懒汉式同步锁

public class LazyMan {

    private static volatile LazyMan lazyMan = null;

    private LazyMan() {
    }

    public static LazyMan getInstatce() {
        synchronized (LazyMan.class){
            if (lazyMan == null) {
                lazyMan = new LazyMan();
            }
        }
        return lazyMan;
    }
}

优点：支持多线程

缺点：每次都会有一个加锁以及释放锁的操作，效率低，可以通过反射破坏单例模式。

4.DCL双检测锁

public class LazyMan {

    private static volatile LazyMan lazyMan = null;

    private LazyMan() {
    }

    public static LazyMan getInstatce() {
        if(lazyMan == null){
            synchronized (LazyMan.class){
                if (lazyMan == null) {
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }
}

这里引入一下解释一下DCL双检测锁机制：

DCL双检测锁机制： 用DCL双检测锁机制为什么要用valoatile修饰，因为lazyMan=new LazyMan()， 并非是一个原子操作。事实上在JVM中大概做了3件事。

1.给lazyMan分配内存，

2.调用构造器来初始化成员变量

3.将lazyMan对象指向分配的内存空间。 但是JVM的即时编译器中存在指令重排序的优化，也就是说上面的第二步，第三步顺序是不 确定的一旦2,3，顺序乱了，这个是有一个线程调用了方法，结果虽然是非null，但是未初 始化，所以直接报错。

优点：效率高，线程安全

缺点：代码复杂，可以通过反射破坏单例

5.静态内部类

public class Singleton {
 
    private Singleton() {}
 
    private static class SingletonInstance {//私有静态内部类
        private static final Singleton INSTANCE = new Singleton();
    }
 
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

优点：类的静态属性只有在第一次加载类的时候初始化，所以线程安全

缺点：代码变得复杂，apk文件增大

6. 枚举单例

public enum SingleTon {

    SINGLE_TON;

    private String field;

    public String getField() {
        return field;
    }

    public void setField(String field) {
        this.field = field;
    }
}

优点：线程安全，不用担心反射破话单例模式

缺点：枚举类占用内存多

解析：object 单例类是什么类型的单例

这里我们直接将kotlin代码转为Java 代码进行查看。

kotlin代码如下

转为Java之后

我们可以看到，该Model类转为Java代码之后，它是一个饿汉式单例。所以使用object的类采用的是饿汉式单例。

companion object伴生对象出现的单例是哪种类型的单例

kotlin代码如下

class  Model{
    companion object{
        val text = ApiWrapper("11")
    }
}

class ApiWrapper (val api : String){
     fun s() {
      
    }
}

java代码如下

public final class Model {
   @NotNull
   private static final ApiWrapper text = new ApiWrapper("11");
   @NotNull
   public static final Model.Companion Companion = new Model.Companion((DefaultConstructorMarker)null);

   public static final class Companion {
      @NotNull
      public final ApiWrapper getText() {
         return Model.text;
      }

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

可以看的出来，如果直接对text赋值，那么就相当于是一个饿汉式加载

但是如果我们对text进行by lazy延迟赋值，那么会是什么样子呢。

public final class Model {
   @NotNull
   private static final Lazy text$delegate;
   @NotNull
   public static final Model.Companion Companion = new Model.Companion((DefaultConstructorMarker)null);

   static {
      text$delegate = LazyKt.lazy((Function0)null.INSTANCE);
   }

   public static final class Companion {
      @NotNull
      public final ApiWrapper getText() {
         Lazy var1 = Model.text$delegate;
         Model.Companion var2 = Model.Companion;
         Object var3 = null;
         return (ApiWrapper)var1.getValue();
      }

      private Companion() {
      }

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

可以看出，此时变成了懒汉式同步单例，

至于为什么是同步单例，这里需要大家去看一下LazyKt.lazy()方法