【设计模式】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相同