线程安全的单例模式 .

来源:互联网 发布:mac怎么看电影天堂 编辑:程序博客网 时间:2024/05/04 12:53
老大一直说要用这个来做面试题,让面试的人来写一个线程安全的单例模式,感觉自己还没掌握,把 Head first--Design Patterns 找了出来,以下大部分内容抄袭自这本书,略有增删改。

 

1. 全局变量的缺点:

 

   必须在程序一开始就创建好对象,如果程序在这次的执行过程中又一直没用到它,就非常耗费资源。

 

2. 经典的单例模式实现:

 

 

Java代码
  1. public class Singleton {    
  2.       //用一个静态变量来记录Singleton类的唯一实例   
  3.       private static Singleton uniqueInstance;   
  4.     
  5.       private Singleton() {}   
  6.            
  7.       //注意这个方法也是静态的   
  8.       public <SPAN style="COLOR: #ff0000">static</SPAN> Singleton getInstance() {    
  9.            if(uniqueInstance == null) {   
  10.              uniqueInstance = new Singleton();   
  11.            }   
  12.            return uniqueInstance;   
  13.       }   
  14. }  
[java] view plaincopyprint?
  1. public class Singleton {   
  2.       //用一个静态变量来记录Singleton类的唯一实例   
  3.       private static Singleton uniqueInstance;  
  4.    
  5.       private Singleton() {}  
  6.           
  7.       //注意这个方法也是静态的   
  8.       public <SPAN style="COLOR: #ff0000">static</SPAN> Singleton getInstance() {   
  9.            if(uniqueInstance == null) {  
  10.              uniqueInstance = new Singleton();  
  11.            }  
  12.            return uniqueInstance;  
  13.       }  
  14. }  
 

 

 

    单例常被用来管理共享的资源,例如数据库连接、线程池、缓存、注册表。

   单例模式确保一个类只有一个实例,并提供一个全局访问点。

 

    这个模式的问题:在多线程时,并不能保证这个类只被实例化一次。

 

3. 处理多线程:

 

    public class Singleton {

Java代码
  1.     //用一个静态变量来记录Singleton类的唯一实例   
  2.     private static Singleton uniqueInstance;   
  3.     
  4.     private Singleton() {}   
  5.            
  6.     //注意这个方法也是静态的   
  7.     public static <SPAN style="COLOR: #ff0000">synchronized</SPAN> Singleton getInstance() {    
  8.         if(uniqueInstance == null) {   
  9.              uniqueInstance = new Singleton();   
  10.          }   
  11.          return uniqueInstance;   
  12.     }   
  13. }  
[java] view plaincopyprint?
  1.     //用一个静态变量来记录Singleton类的唯一实例  
  2.     private static Singleton uniqueInstance;  
  3.    
  4.     private Singleton() {}  
  5.           
  6.     //注意这个方法也是静态的   
  7.     public static <SPAN style="COLOR: #ff0000">synchronized</SPAN> Singleton getInstance() {   
  8.         if(uniqueInstance == null) {  
  9.              uniqueInstance = new Singleton();  
  10.          }  
  11.          return uniqueInstance;  
  12.     }  
  13. }  
 

   通过增加synchronized关键字到getInstance()方法中,迫使每个线程在进入方法之前,要先等别的线程离开该方法。也就是说,不会有两个线程可以同时进入这个方法。

 

   这种方法存在的问题:只有第一次执行此方法时,才真正需要同步。换句话说,一旦设置好uniqueInstance变量,就不再需要同步这个方法了。之后每次调用这个方法,同步都是一种浪费。

 

4.改善多线程

 

4.1 如果getInstance()的性能对应用程序不是很关键,就不用优化了

 

4.2 使用急切创建实例,而不用延迟实例化的做法

 

 

Java代码
  1. public class Singleton {    
  2.   
  3.     <SPAN style="COLOR: #ff0000">private static Singleton uniqueInstance = new Singleton();</SPAN>   
  4.     
  5.     private Singleton() {}   
  6.            
  7.     public static Singleton getInstance() {    
  8.          return uniqueInstance;   
  9.     }   
  10. }  
[java] view plaincopyprint?
  1. public class Singleton {   
  2.   
  3.     <SPAN style="COLOR: #ff0000">private static Singleton uniqueInstance = new Singleton();</SPAN>  
  4.    
  5.     private Singleton() {}  
  6.           
  7.     public static Singleton getInstance() {   
  8.          return uniqueInstance;  
  9.     }  
  10. }  
 

   标红的语句在静态初始化器(static initializer)中创建单例,这保证了线程安全

   利用这个做法,JVM在加载这个类时马上创建此唯一的单件实例。JVM保证任何线程访问uniqueInstance静态变量之前,一定先创建些实例。

 

   4.3 用“双重检查加锁”,在getInstance()中减少使用同步

 

    首先检查实例是否已经创建,如果尚未创建,才进行同步。这样一来,只有第一次会同步,这正是我们想要的。

 

 

Java代码
  1. public class Singleton {    
  2.   
  3.     private volatile static Singleton uniqueInstance;   
  4.     
  5.     private Singleton() {}   
  6.            
  7.     public static Singleton getInstance() {    
  8.     if(uniqueInstance == null) { //(1)  
  9.         //只有第一次才彻底执行这里的代码   
  10.        synchronized() {   
  11.           //再检查一次   
  12.           if(uniqueInstance == null)   
  13.         uniqueInstance = new Singleton();   
  14.        }   
  15.     }   
  16.          return uniqueInstance;   
  17.     }   
  18. }  
[java] view plaincopyprint?
  1. public class Singleton {   
  2.   
  3.     private volatile static Singleton uniqueInstance;  
  4.    
  5.     private Singleton() {}  
  6.           
  7.     public static Singleton getInstance() {   
  8.     if(uniqueInstance == null) { //(1)  
  9.         //只有第一次才彻底执行这里的代码   
  10.        synchronized() {  
  11.           //再检查一次   
  12.           if(uniqueInstance == null)  
  13.         uniqueInstance = new Singleton();  
  14.        }  
  15.     }  
  16.          return uniqueInstance;  
  17.     }  
  18. }  
 

   在最开始如果有1、2、3个线程走到了(1)处,假设1进入了同步块,2、3等待。1实例化后,2进入同步块,发现uniqueInstance已经不为空,跳出同步块。接着3进入,又跳出同步块。

 

    volatile关键字确保:当uniqueInstance变量被初始化成Singleton实例时,多个线程正确地uniqueInstance变量。如果性能是你关心的重点,那么这个做法可以帮你大大地减少getInstance()的时间耗费。

 

转载地址:http://blog.csdn.net/xuyuxin8145/article/details/6638524

0 0