设计模式(1)——单例模式

一、单例设计

        Singleton类中永远只会有一个实例化对象，此种代码实现的根本原理就是在于将一个类的构造方法关闭了。

        当一个类中只能产生一个实例化对象的时候，就需要将构造方法封闭，封闭之后的操作通过一个静态方法取得本类的实例化对象。

1. 1. 构造方法私有化
   2. 本类的一个静态实例
   3. 提供一个静态方法获得本类的实例化对象

 如果要想继续划分的，实际上单例设计，还分成两种类型：

                  ·懒汉式：当第一次使用本类的对象时，在进行对象的实例化操作。

                  ·饿汉式：一个单例类中不管是否使用，都始终维护一个实例化对象。

二、懒汉式

[java]  view plain copy print ?

1. class Singleton {  
2.   
3.          private static Singleton instance =  null ;  
4.   
5.          public static Singleton  getInstance(){       // 将instance传递到外部去  
6.   
7.                    if(instance  == null){  
8.   
9.                             instance  = new Singleton() ;  
10.   
11.                    }  
12.   
13.                    return  instance ;  
14.   
15.          }  
16.   
17.          private Singleton(){}  
18.   
19.          public void print(){  
20.   
21.                    System.out.println("Hello  World!!!") ;  
22.   
23.          }  
24.   
25. };  
26.   
27. public class  Test{   
28.   
29.          public static void main(String  args[]){  
30.   
31.                    Singleton s1 =  Singleton.getInstance() ;  
32.   
33.                    Singleton s2 =  Singleton.getInstance() ;  
34.   
35.                    Singleton s3 =  Singleton.getInstance() ;  
36.   
37.                    s1.print() ;  
38.   
39.                    s2.print() ;  
40.   
41.                    s3.print() ;  
42.   
43.          }  
44.   
45. };  

三、饿汉式

[java]  view plain copy print ?

1. class Singleton {  
2.   
3.          private static final Singleton instance = new  Singleton() ;   // 在内部准备好一个对象  
4.   
5.          public static Singleton getInstance(){       // 将instance传递到外部去  
6.   
7.                    return instance ;  
8.   
9.          }  
10.   
11.          private Singleton(){}  
12.   
13.          public void print(){  
14.   
15.                    System.out.println("Hello  World!!!") ;  
16.   
17.          }  
18.   
19. };  
20.   
21. public class  Test{   
22.   
23.          public static void main(String  args[]){  
24.   
25.                    Singleton s1 =  Singleton.getInstance() ;  
26.   
27.                    Singleton s2 =  Singleton.getInstance() ;  
28.   
29.                    Singleton s3 =  Singleton.getInstance() ;  
30.   
31.                    s1.print() ;  
32.   
33.                    s2.print() ;  
34.   
35.                    s3.print() ;  
36.   
37.          }  
38.   
39. };  

四、单例模式的风险

单例模式很简单，就是在构造函数中多了加一个构造函数，访问权限是private的就可以了，这个模式是简单，但是简单中透着风险，风险？什么风险？在一个B/S项目中，每个HTTP Request请求到J2EE的容器上后都创建了一个线程,每个线程都要创建同一个单例对象,假如现在有两个线程A和线程B，线程A执行到 instance  = new Singleton() ;正在申请内存分配，可能需要0.001微秒，就在这0.001微秒之内，线程B执行到if(instance  == null) 你说这个时候这个判断条件是true还是false？是true，那然后呢？线程B也往下走，于是乎就在内存中就有两个Singleton的实例了，看看是不是出问题了？
如果你这个单例是去拿一个序列号或者创建一个信号资源的时候，会怎么样？业务逻辑混乱！数据一致性校验失败！最重要的是你从代码上还看不出什么问题，这才是最要命的！因为这种情况基本上你是重现不了的，不寒而栗吧，那怎么修改？

[java]  view plain copy print ?

1. public class Singleton {  
2.     private static final Singleton singleton = new Singleton();  
3.   
4.     //限制住不能直接产生一个实例  
5.     private Singleton() {  
6.     }  
7.   
8.     public synchronized static Singleton getInstance() {  
9.         return singleton;  
10.     }  
11. }