设计模式(四)----- 单态模式(Singleton)----(JAVA版)

单态模式(Singleton)：

   保证一个类仅有一个实例，只提供一个访问它的全局访问点

适用性：

 1.当一个类只能有一个实例，而且客户可以从一个众所周知的访问点访问它

2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时

3.Singleton的应用有很多，譬如对数据库只能有一个连接，或者对网站的连接数的计数器。

一个简单的例子：

Singleton

[java]  view plain  copy

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

Test

[java]  view plain  copy

1. public class Test{  
2.   public static void main(String[] args){  
3.     Singleton sing = Singleton.getInstance();  
4.     Singleton sing2 = Singleton.getInstance();  
5.   
6.     System.out.println(sing);  
7.     System.out.println(sing2);  
8. }  

result:

singleton.Singleton@1c78e57

singleton.Singleton@1c78e57

单态模式的几种形势：

Snippet 1  基本形式是使用private constructor和一个public的static方法来获得类的实例。

[java]  view plain  copy

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

     constructor是private，所以如 Singleton s = new Singleton() 不再可行了。只能通过Singleton s = Singleton.getInstance(); 来获得实例，而这个实例因为是static，全局共享一个，所以无论有多少个Singleton s = Singleton.getInstance(); 得到的实例都是同一个。

Snippet 2  采用lazy initialization

[java]  view plain  copy

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

Snippet 2同Snippet 1的区别在于：
    Snippet 1在load class阶段就创建对象了;而Snippet 2只有第一次要实例化的时候才会创建对象。这就是所谓的lazy initialization。

多线程问题
     我们来看snippet 2，如果是单线程，没问题，如果是多线程，问题就出现了，因为两个线程可以同时进入if(instance == null) 这个判断语句，所以有可能两个线程创建两个实例。

Snippet 3

[java]  view plain  copy

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

   然而Snippet 3的问题是在创建了对象之后, instance = new Singleton() 这个语句就再也不会执行了，所以对整个方法进行同步的话效率低下，这样就有人想出了Double-checked locking的方法：

Snippet 4

[java]  view plain  copy

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

这样就解决了问题，仅仅对：

[java]  view plain  copy

1. if(instance == null)  
2.      instance = new Singleton();  

这段代码进行同步，如果对象已经被创建，就不会进入到第一个if代码段里面，所以仅仅在第一次创建的时候会进行同步，效率自然高了。现在看来万无一失了。但问题还没有这么简单。
out-of-order write问题，更多相关资料请见：  DoubleCheckedLocking
instance = new Singleton(); 的顺序应该是

[java]  view plain  copy

1. 1 分配内存  
2. 2 构造函数初始化  
3. 3 将对象的reference赋值给instance  

但因为Java Memory Model的问题，可能出现下面的所谓out-of-order write的问题：

[java]  view plain  copy

1. 1 分配内存  
2. 2 将对象的reference赋值给instance  
3. 3 构造函数初始化  

   也就是还没对对象初始化，就已经instance != null了，这样如果另外一个线程这时候对实例进行操作，可能有意想不到的结果。但仍旧没有好的办法可以完全解决这个问题。

综上，采用Snippet 1或者Snippet 3比较安全。Snippet 2和Snippet 4最好在多线程的环境下不要使用，否则可能会出错。

限制
但Singleton的模式还是有限制的
1 因为采用private constructor，所以Singleton是不能被继承的。
2 如果应用是在容器中运行，就要小心，因为servlet可能在被几个classloader加载，同时有几个Singleton实例存在。
3 另外如果Singleton是可被序列化的(Serializable)，如果序列化一次而反序列化多次就有可能有多个Singleton实例存在。