单例模式

1.什么是单例模式？

  普天之下，为我独尊，一个国家只能有一个皇帝，一个类只产生一个对象。

2.那么单例模式该如何实现呢？

  构造函数私有→其他类不能通过new关键字创建对象
  final关键字→保证对象引用的唯一性
  static关键字→由类本身可以创建对象

3.单例模式的创建（七种）

1）懒汉模式（线程不安全）

public class Singleton{
   private static Singleton instance;
   private Singleton(){}
   public static Singleton getInstance(){
      if(instance == null){
         instance = new Singleton();
      }
      return instance;
   } 
}

2）懒汉模式（加锁）

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

3）饿汉模式（线程安全）

public class Singleton{
   private static Singleton instance = new Singleton();
   private Singleton(){}
   public static Singleton getInstance(){
      return instance;
   } 
}

4）饿汉变种

public class Singleton{
   private static Singleton instance = null;
   static{
      instance = new Singleton();
   }
   private Singleton(){}
   public static Singleton getInstance(){
      return this.instance;
   } 
}

和第三种差不多
5）静态内部类

public class Singleton{
   private static class SingletonHolder{
      private static final Singleton INSTANCE = new Singleton();
   }
   private Singleton(){}
   public static final Singleton getInstance(){
      return SingletonHolder.INSTANCE;
   } 
}

  这种方式利用了ClassLoder的机制来保证初始化实例时只有一个线程，它和第三种和第四种不同的是（细微的差别）：第三种和第四种只要Singleton类被装载了，那么instance就会被实例化，而这种方式是Singleton被装载了，但instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显式通过调用getInstance方法时，才会装载SingletonHolder类，从而实例化。
6)枚举类

public enum Singleton{
   INSTANCE;
   public void whateverMethod(){
   }
}

  他不仅能避免多线程问题，而且还能防止反序列化重新创建新的对象。
  
7）双重校验锁

public class Singleton{
   private volatile static Singleton singleton;
   private Singleton(){}
   public static Singleton getSingleton(){
      if(singleton == null){
         synchronized(Singleton.class){
            if(singleton == null){
               singleton = new Singleton();
            }
         }
      }
      return singleton;
   }
}

  双重校验锁机制是说：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一层检查。进入同步块后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例 ，这是第二层检查。这样就只需要同步一次，从而减少了多次在同步情况下进行判断所浪费的时间。

4.关于单例模式的几个问题

1）饿汉模式先出现，为什么后来又有了懒汉模式？
  答：饿汉模式是在类加载时就初始化了，而懒汉模式是在需要的时候才会被初始化。
2）懒汉模式因为不是原子性操作，所以线程不安全。
3）双重校验锁中volatile关键字的作用？
  答：可见性、可屏蔽性（禁止指令重排序）
  a.可见性：当一条线程修改了这个变量的值，新值对其他线程是立即可知的。但并不是在并发下就是安全的，volatile在各个线程的工作内存中不存在一致性问题，但java运算并非原子操作，所以在并发下一样时不安全的。例如：i++，编译为字节码指令后，不一定是一条字节码，底层还有汇编等，所以不是原子性操作。
    原理：volatile修饰的变量赋值后，会多执行一个“lock addl $0x0,(%esp)”操作，这条指令是把EJP容器的值为0，显然这是一个空操作，lock前缀的作用是使本CPU的Cache写入了内存，相当于对Cache中的变量做了一次"store和write"操作，将此变量同步到主内存中
  b.可屏蔽性：也就是内存屏障。
    例子：

int a1=1;
int a2=2;
volatile int a3=3;
int a4=4;

当没有volatile时，第四条语句可能会先于第三条语句执行，但加上volatile,在第三条语句还未执行完毕，第四条语句不会执行。
4）枚举类的问题
  枚举类单例的保证：枚举的构造方法是私有的，我们在访问枚举类实例时会执行构造方法，同时每一个枚举类实例都是static final类型的，也就表明只能被实例化一次。
  实现不被反序列化：在序列化的时候，java仅仅是将枚举对象的name属性输出到结果中，反序列化的时候则是通过java.lang.Eunm的valueOf方法来根据名字查找枚举对象。同时编译器是不允许任何对这种序列化进制的定制的，因此禁用了writeObject、readObject等方法。