单例模式

1.单例模式
保证一个类仅有一个实例。
(1)实现方式
1、懒汉模式（线程不安全）
2、懒汉模式（线程安全）
3、饿汉模式（线程安全）
4、静态类内部加载（线程安全）
5、枚举方法（线程安全）
6、双重校验锁法（通常线程安全，低概率不安全）
7、带 volatile 的双重校验锁法（线程安全）
8、使用 ThreadLocal 实现单例模式（线程安全）
9、使用 CAS 锁实现（线程安全）
… 实际还有各种奇淫技巧，不只只 9 种方式。

单例模式的安全方式   
单例模式大家并不陌生，也都知道它分为什么懒汉式、饿汉式之类的。但是你对单例模式的理解足够透彻吗？今天我带大家一起来看看我眼中的单例，可能会跟你的认识有所不同。
下面是一个简单的小实例：

1.   //简单懒汉式  
   

public class Singleton {  
        
       //单例实例变量  
       private static Singleton instance = null;  
        
       //私有化的构造方法，保证外部的类不能通过构造器来实例化  
       private Singleton() {}  
        
      //获取单例对象实例  
      public static Singleton getInstance() {  
            
          if (instance == null) {   
              instance = new Singleton();   
          }  
            
          System.out.println("我是简单懒汉式单例！");  
          return instance;  
      }  
  }  

 

 
很容易看出，上面这段代码在多线程的情况下是不安全的，当两个线程进入if (instance == null)时，两个线程都判断instance为空，接下来就会得到两个实例了。这不是我们想要的单例。
 
接下来我们用加锁的方式来实现互斥，从而保证单例的实现。

1.   //同步法懒汉式  
  

public class Singleton {  
    
    //单例实例变量  
    private static Singleton instance = null;  
      
    //私有化的构造方法，保证外部的类不能通过构造器来实例化  
    private Singleton() {}  
      
   //获取单例对象实例  
   public static synchronized  Singleton getInstance() {  
         
       if (instance == null) {   
           instance = new Singleton();   
       }  
         
       System.out.println("我是同步法懒汉式单例！");  
       return instance;  
   }  
}  

 

加上synchronized后确实保证了线程安全，但是这样就是最好的方法吗？很显然它不是，因为这样一来每次调用getInstance()方法是都会被加锁，而我们只需要在第一次调用getInstance()的时候加锁就可以了。这显然影响了我们程序的性能。我们继续寻找更好的方法。
 
经过分析发现，只需要保证instance = new Singleton()是线程互斥就可以保证线程安全，所以就有了下面这个版本：
[java] view plaincopyprint?
1.   //双重锁定懒汉式  

  public class Singleton {  
        
      //单例实例变量  
      private static Singleton instance = null;  
        
      //私有化的构造方法，保证外部的类不能通过构造器来实例化  
      private Singleton() {}  
        
      //获取单例对象实例  
      public static Singleton getInstance() {  
          if (instance == null) {   
              synchronized (Singleton.class) {  
                  if (instance == null) {   
                      instance = new Singleton();   
                  }  
              }  
          }  
          System.out.println("我是双重锁定懒汉式单例！");  
          return instance;  
      }  
  }  

 

这次看起来既解决了线程安全问题，又不至于每次调用getInstance()都会加锁导致降低性能。看起来是一个完美的解决方案，事实上是这样的吗？
很遗憾，事实并非我们想的那么完美。java平台内存模型中有一个叫“无序写”（out-of-order writes）的机制。正是这个机制导致了双重检查加锁方法的失效。这个问题的关键在上面代码上的第5行：instance = new Singleton(); 这行其实做了两个事情：1、调用构造方法，创建了一个实例。2、把这个实例赋值给instance这个实例变量。可问题就是，这两步jvm是不保证顺序的。也就是说。可能在调用构造方法之前，instance已经被设置为非空了。下面我们一起来分析一下：
 
假设有两个线程A、B
1、线程A进入getInstance()方法。
2、因为此时instance为空，所以线程A进入synchronized块。
3、线程A执行 instance = new Singleton(); 把实例变量instance设置成了非空。（注意，是在调用构造方法之前。）
4、线程A退出，线程B进入。
5、线程B检查instance是否为空，此时不为空（第三步的时候被线程A设置成了非空）。线程B返回instance的引用。（问题出现了，这时instance的引用并不是Singleton的实例，因为没有调用构造方法。） 
6、线程B退出，线程A进入。
7、线程A继续调用构造方法，完成instance的初始化，再返回。 
 
难道就没有一个好方法了吗？好的方法肯定是有的，我们继续探索！
[java] view plaincopyprint?
1.   //解决无序写问题懒汉式  

  public class Singleton {  
        
      //单例实例变量  
      private static Singleton instance = null;  
        
      //私有化的构造方法，保证外部的类不能通过构造器来实例化  
      private Singleton() {}  
        
      //获取单例对象实例  
      public static Singleton getInstance() {  
          if (instance == null) {   
              synchronized (Singleton.class) {                  //1  
                  Singleton temp = instance;                //2  
                  if (temp == null) {  
                      synchronized (Singleton.class) {  //3   
                          temp = new Singleton();   //4      
                      }  
                      instance = temp;                  //5        
                  }  
              }  
          }  
          System.out.println("我是解决无序写懒汉式单例！");  
          return instance;  
      }     
  }   

 
1、线程A进入getInstance()方法。
 
2、因为instance是空的 ，所以线程A进入位置//1的第一个synchronized块。
3、线程A执行位置//2的代码，把instance赋值给本地变量temp。instance为空，所以temp也为空。 
4、因为temp为空，所以线程A进入位置//3的第二个synchronized块。（后来想想这个锁有点多余）
5、线程A执行位置//4的代码，把temp设置成非空，但还没有调用构造方法！（“无序写”问题） 
6、如果线程A阻塞，线程B进入getInstance()方法。
7、因为instance为空，所以线程B试图进入第一个synchronized块。但由于线程A已经在里面了。所以无法进入。线程B阻塞。
8、线程A激活，继续执行位置//4的代码。调用构造方法。生成实例。
9、将temp的实例引用赋值给instance。退出两个synchronized块。返回实例。
10、线程B激活，进入第一个synchronized块。
11、线程B执行位置//2的代码，把instance实例赋值给temp本地变量。
12、线程B判断本地变量temp不为空，所以跳过if块。返回instance实例。
 
到此为止，上面的问题我们是解决了，但是我们突然发现为了解决线程安全问题，但给人的感觉就像身上缠了很多毛线.... 乱糟糟的，所以我们要精简一下：
[java] view plaincopyprint?
1.   //饿汉式  

  public class Singleton {  
        
      //单例变量 ,static的，在类加载时进行初始化一次，保证线程安全   
      private static Singleton instance = new Singleton();      
        
      //私有化的构造方法，保证外部的类不能通过构造器来实例化。       
      private Singleton() {}  
        
      //获取单例对象实例       
      public static Singleton getInstance() {  
          System.out.println("我是饿汉式单例！");  
          return instance;  
      }  
  }  

 

看到上面的代码，瞬间觉得这个世界清静了。不过这种方式采用的是饿汉式的方法，就是预先声明Singleton对象，这样带来的一个缺点就是：如果构造的单例很大，构造完又迟迟不使用，会导致资源浪费。
 
到底有没有完美的方法呢？继续看：
[java] view plaincopyprint?
1.   //内部类实现懒汉式  

public class Singleton {  
      
    private static class SingletonHolder{  
        //单例变量    
        private static Singleton instance = new Singleton();  
    }  
      
    //私有化的构造方法，保证外部的类不能通过构造器来实例化。  
    private Singleton() {  
          
    }  
      
    //获取单例对象实例  
    public static Singleton getInstance() {  
        System.out.println("我是内部类单例！");  
        return SingletonHolder.instance;  
    }  
}  

 

懒汉式（避免上面的资源浪费）、线程安全、代码简单。因为java机制规定，内部类SingletonHolder只有在getInstance()方法第一次调用的时候才会被加载（实现了lazy），而且其加载过程是线程安全的（实现线程安全）。内部类加载的时候实例化一次instance。
 
简单说一下上面提到的无序写，这是jvm的特性，比如声明两个变量，String a; String b; jvm可能先加载a也可能先加载b。同理，instance = new Singleton();可能在调用Singleton的构造函数之前就把instance置成了非空。这是很多人会有疑问，说还没有实例化出Singleton的一个对象，那么instance怎么就变成非空了呢？它的值现在是什么呢？想了解这个问题就要明白instance = new Singleton();这句话是怎么执行的，下面用一段伪代码向大家解释一下：
[plain] view plaincopyprint?
1.   mem = allocate();             //为Singleton对象分配内存。  
2.   instance = mem;               //注意现在instance是非空的，但是还没有被初始化。  
3.     
4.   ctorSingleton(instance);    //调用Singleton的构造函数，传递instance.  
 
由此可见当一个线程执行到instance = mem; 时instance已为非空，如果此时另一个线程进入程序判断instance为非空，那么直接就跳转到return instance;而此时Singleton的构造方法还未调用instance，现在的值为allocate();返回的内存对象。所以第二个线程得到的不是Singleton的一个对象，而是一个内存对象。
 
源文档 <http://blog.163.com/yanjingyu_happy/blog/static/111639566201364115047132/>
(2)应用场景
①　在spring中scope参数的缺省值
a.饿汉模式
Spring singleton缺省是饿汉模式。启动容器（实例化容器）时，为所有spring配置文件中定义的bean都生成一个实例。
b.懒汉模式 
<beans default-lazy-init=”true”>

②　网站在线人数的统计。
其实就是全局计数器，也就是说所有用户在相同的时刻获取到的在线人数数量都是一致的。要实现这个需求，计数器就要全局唯一，也就正好可以用单例模式来实现。
③　配置文件访问类
④　数据库连接池，线程池。
为什么要做池化，是因为新建连接很耗时，如果每次新任务来了，都新建连接，那对性能的影响实在太大。所以一般的做法是在一个应用内维护一个连接池，这样当任务进来时，如果有空闲连接，可以直接拿来用，省去了初始化的开销。所以用单例模式，正好可以实现一个应用内只有一个线程池的存在，所有需要连接的任务，都要从这个连接池来获取连接。如果不使用单例，那么应用内就会出现多个连接池，那也就没什么意义了。如果你使用 Spring 的话，并集成了例如 druid 或者 c3p0 ，这些成熟开源的数据库连接池，一般也都是默认以单例模式实现的。