单例模式概述

• 单例模式实现方式
• 为什么要使用单例模式

单例模式实现方式

饿汉式

类加载后就会将对象加载到内存中，保证对象唯一

• 优点：由于是类加载后就创建到内存，故不存在线程安全问题
• 缺点：用或者不用，都会直接创建对象，会导致浪费内存问题

// java实现
public class Singleton {
  private static Singleton instance = new Singleton();
  private Singleton() {}
    
  public static Singleton getInstance() {
    return instance;
  }
}

//kotlin实现
object Singleton{
}

懒汉式

懒汉模式在调用的时候才会创建对象，延迟创建，多线程可能会创建多个实例对象

• 优点：调用的时候才创建，节省空间
• 缺点：多线程下可能会创建多个实例对象

// java：
public class Singleton{
  private static Singleton instance = null;
  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() {
        return instance!!
      } 
  }
}

线程安全

线程安全是懒汉式的扩展，并解决多线程下，仍然保持只创建单个实例，在创建对象的方法加synchronized关键字修饰，这样就可以保证实例对象只会创建一个。

• 优点：不存在多线程风险，并且延迟创建
• 缺点：在多线程下会导致bloc情况，如：有多个线程同时调用方法，其中一个抢占资源执行创建实例对象，如果当前创建比较耗时，则其他线程会被bloc

// java：
public class Singleton{
  private static Singleton instance = null;
  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() {
        return instance!!
      } 
  }
}

双重检索

双重检索是线程安全方式的进阶版，第一次判空是为了判断当前对象是否被创建，第二次判断在synchronized后，是为了判断多个线程同时进入的情况下，对象是否已经创建，这样就保证了实例对象创建了一次。如：同时有两个对象同时进入bloc到synchronized这，这个时候，线程A抢到资源，就会进入到synchronized的代码块内，这个时候就会执行创建实例对象，完成之后线程B才会进入，这个时候再判断是否为空的时候就会为false，可以直接返回对象。

• 优点：

  • 提升了效率，避免了线程安全时多个线程同时bloc在synchroized外面。
  • 保证唯一，同一时刻只有一个线程能创建对象

• 缺点：代码比较多（^_）

• 双重检索会遇到空指针的问题，需要使用volatile关键字，在多线程并发的情况出现java指令重排序的问题，导致对象创建成功之后，未及时同步到主存中，导致其他线程认为主存对象还为null，导致空指针。

  • volatile关键字：保证可见性

// java：
public class Singleton{
  private volatile static Singleton instance = null;
  private Singleton() {}
  
  public static Singleton getInstance() {
    if(instance == null) {
      synchronized() {
        if(instance == null) {
           instance = new Singleton();
        }
      }
    }
    return instance;
  }
}
// kotlin：
// 无参数情况
class Singleton private constructor() {
  companion object {
    val INSTANCE: Singleton by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
      Singleton()
    }
  }
}
// 有参数情况
class Singleton private constructor(v1: Int) {
  companion object {
    @Volatile
    private var instance: Singleton? = null
    fun getInstance(property: Int) = 
      instance ?: synchronized(this) {
        instance ?: Singleton(property).also {
          instance = it
        }
      }
  }
}

静态内部类

静态内部类能保证线程唯一也是线程安全的，也能延迟加载，主要是类加载机制，当类被加载的时候，内部类并不会被加载，只有使用的时候才会创建实例加载到内存中，所以能保证实例对象唯一，也能延迟加载

• 优点： 保证唯一，延迟加载，代码简洁

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

为什么要使用单例模式

• 减少对象创建，避免频繁调用GC带来的性能问题
• 用时创建，减少内存消耗
• 多线程中数据不一致导致的问题

项目中常见的单例模式

• 使用网络请求，如：OKHttp全局可以使用一个OKHttpClient实例对象