创建型模式之单例模式

单例模式（Singleton Pattern）:单例模式确保其某一类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类成为单例类，它提供全局访问的方法。

一般 情况下，单例模式的实现代码如下：
在单例模式的实现过程中，需要注意如下三点：
（1）单例类的构造函数为私有；
（2）提供一个自身静态私有成员变量；
（3）提供一个公有的静态工厂方法。

代码实现：
1、懒汉式单例，线程不安全，私有静态变量 instance被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 instance，从而节约资源。但是，这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 if (instance== null) ，并且此时 instance为 null，那么会有多个线程执行 instance = new Singleton(); 语句，这将导致实例化多次 instance，违背了单例模式的动机。

 public class Singleton
   {
   private static Singleton instance=null;//静态私有成员变量
       public Singleton(){//私有构造函数
       }
       //静态公有工厂方法，返回唯一实例
        public static Singleton getInstance()
        {
         if(instance==null)
         {
            instance=new Singleton();
            return instance;
     }

          }
 }    

2、饿汉式单例：
线程不安全的原因主要是多个线程多次实例化instance，而直接实例化instance则可以避开这个问题，但是直接实例化instance确会失去延迟实例化带来的节约资源的好处。

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

3、懒汉式-线程安全
对getInstance 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了实例化多次 instance。但是当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待，即使 instance 已经被实例化了。这会让线程阻塞时间过长，因此该方法有性能问题，不推荐使用。

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

}

4、双重检查锁定-线程安全
instance 只需要被实例化一次，之后就可以直接使用。加锁操作只需要对实例化那部分进行，只有当instance没有被实例化时，才需要进行加锁。

public class Singeleton{
     private volatile  static Singleton instance;
     private Singleton(){}
     public static Singleton getInstance(){
      if(instance==null){
          synchronized(Singleton.Class){
              if(instance==null){
                  instance=new Singleton();    }
            }
        } 
 }
}

为什么需要关键字 volatile？
因为volatile能够禁止指令重排序。
JVM对于双重检查锁定代码中的两个if会将它们合成一个，也就是进行一次代码的优化，但是我们需要这两个if语句分开作用，所以使用volatile来禁止这种指令重排序，达到按照我们写代码的逻辑去运行。

5、IoDh（静态内部类）
当Singleton类被加载是，静态内部类singletonST 没有被加载进内存、只有当调用getInstance方法时，触发singletonST.instance时才会被加载，此时初始化instance实例，并且JVM能够确保instance只被实例化一次。这种静态内部类实现方式，不仅具有 延迟初始化的好处，而且又 JVM 提供了对线程安全的支持。

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