设计模式之单例模式

一、简单介绍

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。

《设计模式》书中对单例模式动机的介绍

对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID(序号)生成器。如在Windows中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要。 
如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。

二、类图

三、实现

主要有两点需要特别注意：

一点是构造方法必须是private的，否则不能保证只有一个实例

另一个是必须有pulic static的获取实例方法或者public static的实例属性，保证外部能访问

1、最基本的懒汉方式实现，线程不安全

[java]  view plain  copy

1. package com.designpattern.singleton;  
2.   
3. /** 
4.  * 懒汉，线程不安全 
5.  *  
6.  * @author chao 
7.  * 
8.  */  
9. public class Singleton1 {  
10.     private static Singleton1 instance;  
11.   
12.     private Singleton1() {  
13.     }  
14.   
15.     public static Singleton1 getInstance() {  
16.         if (instance == null) {  
17.             instance = new Singleton1();  
18.         }  
19.         return instance;  
20.     }  
21. }  

2、在public static Singleton1 getInstance()方法上加上同步关键字synchronized就能保证线程安全，但是影响了执行效率。

3、比较常用的高效的线程安全的单利模式实现是加双重锁

[java]  view plain  copy

1. package com.designpattern.singleton;  
2.   
3. /** 
4.  * 线程安全的单例模式，双重锁校验 
5.  *  
6.  * @author chao 
7.  * 
8.  */  
9. public class Singleton3 {  
10.     private volatile static Singleton3 instance;  
11.   
12.     private Singleton3() {  
13.     }  
14.   
15.     public static Singleton3 getSingleton() {  
16.         if (instance== null) {  
17.             synchronized (Singleton3.class) {  
18.                 if (singleton == null) {  
19.                     instance = new Singleton3();  
20.                 }  
21.             }  
22.         }  
23.         return instance;  
24.     }  
25. }  

需要特别注意的是一定要加volatile关键字，这样才能保证在内存中访问到的是最新值，从而有效的做双重判断，保证只有一个instance对象。

4、饿汉模式，类初始化的时候创建

[java]  view plain  copy

1. package com.designpattern.singleton;  
2.   
3. /** 
4.  * 饿汉方式创建 
5.  *  
6.  * @author chao 
7.  * 
8.  */  
9. public class Singleton4 {  
10.     private static Singleton4 instance = null;//也可以直接对instance赋值，效果相同  
11.     static {  
12.         instance = new Singleton4();  
13.     }  
14.   
15.     private Singleton4() {  
16.     }  
17.   
18.     public static Singleton4 getInstance() {  
19.         return instance;  
20.     }  
21. }  

这种方式有很大的缺点，就是不能接收外部参数，getInstance方法一定是无参的。因为在getInstance方法之前，其实instance已经有了实例。

 这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

5、饿汉模式改进版，利用内部类实现懒加载

[java]  view plain  copy

1. /** 
2.  * 懒加载的饿汉单例模式 
3.  *  
4.  * @author chao 
5.  * 
6.  */  
7. public class Singleton5 {  
8.     private static class SingletonHolder {  
9.         private static final Singleton5 INSTANCE = new Singleton5();  
10.     }  
11.   
12.     private Singleton5() {  
13.     }  
14.   
15.     public static final Singleton5 getInstance() {  
16.         return SingletonHolder.INSTANCE;  
17.     }  
18. }  

这种方式Singleton类即使被装载了，instance也不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，而且实现了懒加载。但是getInstance方法同样不支持传参数。

6、枚举实现单例模式

以上方法都有一个问题，就是不能方式反射方法破坏单例模式。如果使用反射，还是可以创建多个实例的。

Joshua Bloch的《Effective Java》一书中提到了单例模式枚举的实现，保证只有一个实例（即使使用反射机制也无法多次实例化一个枚举量），并且线程安全。

看起来很好，但是很少见到真正有这么用的。

[java]  view plain  copy

1. package com.designpattern.singleton;  
2.   
3. /** 
4.  * 利用枚举实现单利 
5.  *  
6.  * @author chao 
7.  * 
8.  */  
9. public enum Singleton {  
10.     INSTANCE;  
11.     public Object buid() {  
12.         return new Object();  
13.     }  
14. }