【設計模式】5、單例模式

原始單例模式

 1 package com.shejimoshi.create.Singleton;
 2 
 3 
 4 /**
 5  * 功能：保證一個類僅有一個實例，並提供一個訪問它的全局訪問點
 6  * 適用：1、當類只能有一個實例而且客戶可以從一個眾所周知的訪問點訪問他的時候
 7  *    ：2、當這個唯一實例應該是通過子類化可以擴展的，並且可以應該無需更改代碼就能使用一個擴展實例時
 8  *    單例模式基礎版
 9  * 時間：2016年2月15日下午7:59:47
10  * 作者：cutter_point
11  */
12 public class Singleton
13 {
14     //構造函數私有化
15     private Singleton(){}
16     //數據成員單例
17     private static Singleton single = null;
18     
19     //這個就是返回一個單例
20     public static Singleton getInstance()
21     {
22         if(single == null)
23             single = new Singleton();
24         
25         return single;
26     }
27 }

 單例模式之多線程單例

 1 package com.shejimoshi.create.Singleton;
 2 
 3 
 4 /**
 5  * 功能：保證一個類僅有一個實例，並提供一個訪問它的全局訪問點
 6  * 適用：1、當類只能有一個實例而且客戶可以從一個眾所周知的訪問點訪問他的時候
 7  *    ：2、當這個唯一實例應該是通過子類化可以擴展的，並且可以應該無需更改代碼就能使用一個擴展實例時
 8  *    單例模式之多線程單例
 9  * 時間：2016年2月15日下午8:05:41
10  * 作者：cutter_point
11  */
12 public class Singleton2
13 {
14     //構造函數私有化
15     private Singleton2(){}
16     //數據成員單例
17     private static Singleton2 single = null;
18     
19     //這個就是返回一個單例,這裡加鎖為了同步
20     public static synchronized Singleton2 getInstance()
21     {
22         if(single == null)
23             single = new Singleton2();
24         
25         return single;
26     }
27 }

單例模式之雙重鎖保證同步

 1 package com.shejimoshi.create.Singleton;
 2 
 3 
 4 /**
 5  * 功能：保證一個類僅有一個實例，並提供一個訪問它的全局訪問點
 6  * 適用：1、當類只能有一個實例而且客戶可以從一個眾所周知的訪問點訪問他的時候
 7  *    ：2、當這個唯一實例應該是通過子類化可以擴展的，並且可以應該無需更改代碼就能使用一個擴展實例時
 8  *    單例模式之雙重鎖保證同步
 9  * 時間：2016年2月15日下午8:06:55
10  * 作者：cutter_point
11  */
12 public class Singleton3
13 {
14     //構造函數私有化
15     private Singleton3(){}
16     //數據成員單例
17     private static Singleton3 single = null;
18     
19     //這個就是返回一個單例,這裡加鎖為了同步
20     public static Singleton3 getInstance()
21     {
22         if(single == null)
23         {
24             //這裡上鎖等待同步
25             synchronized(Singleton3.class)
26             {
27                 if(single == null)
28                 {
29                     //這裡加一個判斷是為了避免在上鎖的時候其他線程創建了相應的實例，所以這裡再判斷一次
30                     single = new Singleton3();
31                 }//if
32             }
33         }
34         
35         return single;
36     }
37 }

單例模式之靜態內部類

 1 package com.shejimoshi.create.Singleton;
 2 
 3 
 4 /**
 5  * 功能：保證一個類僅有一個實例，並提供一個訪問它的全局訪問點
 6  * 適用：1、當類只能有一個實例而且客戶可以從一個眾所周知的訪問點訪問他的時候
 7  *    ：2、當這個唯一實例應該是通過子類化可以擴展的，並且可以應該無需更改代碼就能使用一個擴展實例時
 8  *    單例模式之靜態內部類
 9  * 參考：http://www.blogjava.net/kenzhh/archive/2013/03/15/357824.html
10  * 時間：2016年2月15日下午8:09:47
11  * 作者：cutter_point
12  */
13 public class Singleton4
14 {
15     //靜態類部類，java靜態內部類只有在載入內部類的時候才初始化，所以這種實現方式可以實現懶載入
16     private static class SingletonHolder
17     {
18         private static final Singleton4 INSTANCE = new Singleton4();
19     }
20     
21     //構造函數私有化
22     private Singleton4(){}
23     
24     public static final Singleton4 getInstance()
25     {
26         return SingletonHolder.INSTANCE;    //也就是說只有在調用這個的時候才進行初始化，然後以後在生存周期內都是這個引用
27     }
28 }

測試代碼：

 1 package com.shejimoshi.create.Singleton;
 2 
 3 
 4 /**
 5  * 功能：保證一個類僅有一個實例，並提供一個訪問它的全局訪問點
 6  * 適用：1、當類只能有一個實例而且客戶可以從一個眾所周知的訪問點訪問他的時候
 7  *    ：2、當這個唯一實例應該是通過子類化可以擴展的，並且可以應該無需更改代碼就能使用一個擴展實例時
 8  * 時間：2016年2月15日下午8:29:05
 9  * 作者：cutter_point
10  */
11 public class Test
12 {
13 
14     public static void main(String[] args)
15     {
16         Singleton s1 = Singleton.getInstance();
17         Singleton s2 = Singleton.getInstance();
18         
19         if(s1 == s2)
20         {
21             System.out.println("s1和s2相同");
22         }
23         
24         Singleton2 s3 = Singleton2.getInstance();
25         Singleton2 s4 = Singleton2.getInstance();
26         
27         if(s3 == s4)
28         {
29             System.out.println("s3和s4相同");
30         }
31         
32         Singleton3 s5 = Singleton3.getInstance();
33         Singleton3 s6 = Singleton3.getInstance();
34         
35         if(s5 == s6)
36         {
37             System.out.println("s5和s6相同");
38         }
39         
40         Singleton4 s7 = Singleton4.getInstance();
41         Singleton4 s8 = Singleton4.getInstance();
42         
43         if(s7 == s8)
44         {
45             System.out.println("s7和s8相同");
46         }
47     }
48 
49 }

結果：

1 s1和s2相同
2 s3和s4相同
3 s5和s6相同
4 s7和s8相同