Singleton和Double-Checked Locking设计模式,分别指的是单例模式和双重检查锁模式，它们都可以用于确保某个类只有一个对象实例化。

两个模式的区别在于：Singleton模式用在单线程应用程序中，而Double-Checked Locking模式用于多线程模式。

UML图：

代码：

[java] view plaincopy

 

1. package bupt.xujinliang.singletonpattern;  
2. /** 
3.  *  
4.  * @author jin 
5.  * 
6.  */  
7. public class SingletonExample {  
8.     public static void main(String[] args) {  
9.         Printer printer1 = Printer.getInstance();  
10.         Printer printer2 = Printer.getInstance();  
11.         if(printer1 == printer2) {  
12.             System.out.println("printer2 point to the same address with printer1");  
13.         } else {  
14.             System.out.println("printer2 point to different address with printer1");  
15.         }  
16.     }  
17. }  
18. class Printer {  
19.     private static Printer instance;  
20.     public Printer() {  
21.         System.out.println("Printer Constructor");  
22.     }     
23.     public static Printer getInstance() {  
24.         if(null == instance)   
25.             instance = new Printer();  
26.         return instance;  
27.     }  
28. }  

运行结果：

2.Double-Checked Locking模式

[cpp] view plaincopy

 

1. Printer* get_instance(void)  
2. {  
3.     lock();  
4.     if( instance == 0) {  
5.        instance = new Printer;  
6.     }  
7.     unlock();  
8.     return instance;  
9. }  

上述代码存在的问题是：无论是否已经初始化都要加锁,增加了负荷,已经没有所谓的并发性能了。

[cpp] view plaincopy

 

1. Printer* get_instance(void)  
2. {   
3.     if( instance == 0){  
4.         lock();  
5.         instance = new Printer;  
6.         unlock();  
7.     }  
8.     return instance;  
9. }  

上述代码存在的问题是：不能保证临界区只初始化一次,没能实现singleton的基本功能。

[cpp] view plaincopy

 

1. Printer* get_instance(void)  
2. {   
3.     if( instance == 0){  
4.         lock();  
5.         if( instance == 0 )  
6.             instance = new Printer;  
7.         unlock();  
8.     }  
9.     return instance;  
10. }  

这是比较完善的Double-Checked Locking模式实现的代码。

[java] view plaincopy

 

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

上面程序真正的问题是没有同步的情况下读取共享变量resource，并发的情况下对象的状态值有可能是过期无效的。要解决这个问题也很简单，把resource声明为volatile类型。volatile有什么作用？引用《java并发编程实战》的解析：

[plain] view plaincopy

 

1. 当一个域声明为volatile类型后，编译器与运行时会监视这个变量：它是共享的，而且对它的操作不会与其他的内存操作一起被重排序。volatile变量不会缓存在寄存器或缓存在对其他处理器隐藏的地方。所以，读一个volatile类型的变量时，总会返回由某一线程所写入的最新值。  

读取volatile变量比读取非volatile变量的性能几乎没有差别，不过需要注意的是volatile只能保证内存可见性，并不能保证原子性。

[plain] view plaincopy

 

1. class Printer {  
2.     private static class Instance {  
3.         static final Printer instance = new Printer();  
4.     }  
5.     private static Printer resource ;  
6.     public static Printer getInstance(){          
7.         return Instance.instance;  
8.     }     
9.     private Printer(){}  
10. }  

上述方法之所以有效，是因为内部类（Instance）将只被装载一次，所以只会创建一个对象。