设计模式之单例模式

每天一篇系列：
强化知识体系，查漏补缺。
欢迎指正，共同学习！

单例模式即只有一个对象实例，通常包括懒汉模式和饿汉模式。而懒汉模式又有线程安全的设计。
a)懒汉模式
最简单的写法

public class TEST7{
  private TEST7(){}
  public static TEST7 mInstance = null；
  public static TEST7 getInstance(){
    if(mInstance  == null){
      mInstance  = new TEST7()；
    }
  }
}

虽然简单，但是在并发情况下不安全，因此可以简单的加个同步：

public class TEST7{
  private TEST7(){}
  public static TEST7 mInstance = null；
  public static TEST7 getInstance(){
    synchronized(TEST7.class){
      if(mInstance  == null){
        mInstance  = new TEST7()；
      }
    }
  }
}

由于加了一个同步，在并发时要多次使用synchronized导致效率变慢，避开过多的同步可以加个双重检查(synchronized修饰不加static的方法，锁是加在单个对象上，不同的对象没有竞争关系；修饰加了static的方法，锁是加载类上，这个类所有的对象竞争一把锁)：

public class TEST7{
  private TEST7(){}
  public static TEST7 mInstance = null；
  public static TEST7 getInstance(){
    if(mInstance  == null){
         //等同于把锁加在static方法上
         synchronized(TEST7.class){
          if(mInstance  == null){
            mInstance  = new TEST7()；
          }
        }
    }
  }
}

然而，就算有了双重检查在并发情况下也不是原子操作，来分析下为什么会出现问题。由于Java 平台内存模型，JAVA虚拟机会默认优化指令排序，也就是说指令执行的顺序可能和你预想的不一样，假如mInstance = new TEST7()这段代码的实际执行顺序如下：

mem = allocate();             //为单例对象分配内存空间.
instance = mem;               //注意，minstance 引用现在是非空，但还未初始化
ctorSingleton(minstance);    //为单例对象通过instance调用构造函数

那么就有可能因为同步块外面的if (mInstance == null)可能看到已存在，但还有部分未初始化完整的实例，而导致程序崩溃。
使用volatile可以解决这个问题：

public class TEST7{
  private TEST7(){}
  public static volatile TEST7 mInstance = null;
  public static TEST7 getInstance(){
    if(mInstance  == null){
         synchronized(TEST7.class){
          if(mInstance  == null){
            mInstance  = new TEST7()；
          }
        }
    }
  }
}

volatile涉及到线程从高速缓存与主存(栈与堆)的读写，使用volatile实际上保证线程的对该实例的操作每次都是从主存上来的，这样达到一致性。
懒汉的方式是在第一次调用getInstance时进行初始化。效率上并不是立即的，而饿汉式利用了static的特性，在类加载时就初始化实例。
b)饿汉式
饿汉式就是利用static关键字在类加载时就初始化实例，以后不再改变，本身就是线程安全的。

public class TEST7{
  private TEST7(){}
  public static final TEST7 mInstance = new TEST7()；
  public static TEST7 getInstance(){
    return mInstance；
  }
}

静态内部类方式：

public class TEST7{
  private TEST7(){}
  public static class TEST8{
    public static final TEST7 mInstance = new TEST7()；
  }
  public static TEST7 getInstance(){
    return TEST8.mInstance；
  }
}

静态内部类的单例模式的好处是，在类加载时就已经完成了单例对象的创建，而且static的声明保证了只会加载一次，本身就是线程安全的(多线程每次运行结果和单线程运行的结果预期是一样的)，又避免了同步带来的性能影响。虽然没有了线程安全的影响，但也正是类在加载的时候就会创建实例，相比懒汉式会提前占用了内存资源，即资源利用效率懒汉式要好。

最后编辑于：2018.11.03 12:47:37