"围观"设计模式(7)--创建型之单例模式(Singleton Pattern)

单例模式，也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。----维基百科（WIKIPEDIA）

个人的理解：

单例模式概念比较简单，他的目的就是只允许出现一个该类的实例，经常在JDBC操作类等处被用到，我在项目中应用到的地方就是用于获取Dao层的类的实例，单例模式有多种实现方式，这里我认知到的有饿汉式、懒汉式、枚举、静态内部类。庆幸这次整理过程，因为又拓展了不少的单例模式的知识。

下面看实际的例子：

懒汉式

[java]  view plain  copy

1. </pre><span style="font-size:18px;"><span style="font-size:12px;"></span></span><pre name="code" class="java">public class Singleton01 {  
2.   
3.     private static Singleton01 singleton = null;  
4.       
5.     private Singleton01(){}  
6.       
7.     public static Singleton01 getInstance(){  
8.           
9.         if(singleton == null)  
10.             singleton = new Singleton01();  
11.           
12.         return singleton;  
13.     }  
14. }  

线程不安全，当多个线程同时调用getInstance方法时，都检测到singleton为null，然后就开始创建对象了，这时候就会创建多个实例，而不是一个。

[java]  view plain  copy

1. public class Singleton02 {  
2.   
3.     private static Singleton02 singleton = null;  
4.       
5.     private Singleton02(){}  
6.       
7.     public synchronized static Singleton02 getInstance(){  
8.           
9.         if(singleton == null)  
10.             singleton = new Singleton02();  
11.           
12.         return singleton;  
13.     }  
14. }  

这个例子线程安全了，多个线程同时调用的时候也不会创建多个对象实例了，但是不是很高效，需要多个线程依次的去执行这个方法。

[java]  view plain  copy

1. public class Singleton03 {  
2.   
3.     private static Singleton03 singleton = null;  
4.       
5.     private Singleton03(){}  
6.       
7.     public static Singleton03 getInstance(){  
8.           
9.         if(singleton == null)  
10.             synchronized (Singleton03.class) {  
11.                   
12.                 if(singleton == null){  
13.                     singleton = new Singleton03();  
14.                 }  
15.             }         
16.           
17.         return singleton;  
18.     }  
19. }  

这种方式被称为Double Check（双重检验）,比较经典的设计，为什么要两次呢？先说外面的判断是避免对象已经创建好了之后，就不用再去同步执行创建对象去了，第二个是，防止第一次还没有创建实例的时候，多个线程已经在等待中，这个时候需要进行空的判断。防止后面等待的现场进入之后再次创建实例。

参考了其他人的文章【1】：

singleton = new Singleton()不是原子操作，在JVM中大致做了三件事情：

1. 给instance分配内存。

2. 通过其构造函数初始化成员变量。

3. 将instance指向分配的内存空间。（执行完instance就不是null了）。

但是在JVM编译器中存在指令重新排序的优化，最终的执行顺序是1-2-3或者1-3-2，如果是1-3-2的话，那么在3执行完毕，2执行之前，线程A被线程B抢断的话，instance非空，线程B会直接返回instance，这个时候，直接使用就会报错。

给出的解决方式(使用volatile关键字屏蔽重排序)是：

[java]  view plain  copy

1. public class Singleton03 {  
2.   
3.     private volatile static Singleton03 singleton = null;  
4.       
5.     private Singleton03(){}  
6.       
7.     public static Singleton03 getInstance(){  
8.           
9.         if(singleton == null)  
10.             synchronized (Singleton03.class) {  
11.                   
12.                 if(singleton == null){  
13.                     singleton = new Singleton03();  
14.                 }  
15.             }         
16.           
17.         return singleton;  
18.     }  
19. }  

饿汉式

[java]  view plain  copy

1. public class Singleton04 {  
2.   
3.     private static final Singleton04 singleton = new Singleton04();  
4.       
5.     private Singleton04(){  
6.     }  
7.       
8.     public static Singleton04 getInstance(){  
9.         return singleton;  
10.     }  
11. }  

这种方式是线程安全的，不过不足的一点是，即使没有调用getInstance方法，也会产生他的实例。之前的懒汉式的方式是懒加载的思想，在需要的时候创建。

静态内部类

[java]  view plain  copy

1. public class Singleton05 {  
2.   
3.     private static class Singleton{  
4.         private static final Singleton05 instance = new Singleton05();  
5.     }  
6.       
7.     private Singleton05(){  
8.     }  
9.       
10.     public Singleton05 getInstance(){  
11.         return Singleton.instance;  
12.     }  
13. }  

采用了静态内部类的方式，私有的静态内部类，外部无法访问，类似于饿汉式的形式，但是在此基础上进行了改进，饿汉式是使用的内部属性，而这个是 使用的静态内部类的常量。

枚举

神一样的设计，使用枚举实现单例模式的几个原因：

1. 自由序列化

2. 线程安全

3. 保证只有一个实例。

[java]  view plain  copy

1. public enum Singleton06 {  
2.   
3.     INSTANCE;  
4.       
5.     private Singleton06(){  
6.     }  
7.       
8.     public void print(){  
9.         System.out.println("Enum Singleton!");  
10.     }  
11. }  

调用：

[java]  view plain  copy

1. Singleton06.INSTANCE.print();  

代码下载

下载代码

参考

【1】 http://wuchong.me/blog/2014/08/28/how-to-correctly-write-singleton-pattern/