现在的位置: 首页 > 综合 > 正文

设计模式——小单例有大秘密

2013年08月07日 ⁄ 综合 ⁄ 共 3221字 ⁄ 字号 小 中 大 ⁄ 评论关闭

单例模式大家并不陌生，也都知道它分为什么懒汉式、饿汉式之类的。但是你对单例模式的理解足够透彻吗？今天我带大家一起来看看我眼中的单例，可能会跟你的认识有所不同。

下面是一个简单的小实例：

[java] view plaincopyprint?

  1. //简单懒汉式  
  2. public class Singleton {  
  3.       
  4.     //单例实例变量  
  5.     private static Singleton instance = null;  
  6.       
  7.     //私有化的构造方法，保证外部的类不能通过构造器来实例化  
  8.     private Singleton() {}  
  9.       
  10.     //获取单例对象实例  
  11.     public static Singleton getInstance() {  
  12.           
  13.         if (instance == null) {   
  14.             instance = new Singleton();   
  15.         }  
  16.           
  17.         System.out.println("我是简单懒汉式单例！");  
  18.         return instance;  
  19.     }  
  20. }  


很容易看出，上面这段代码在多线程的情况下是不安全的，当两个线程进入if (instance == null)时，两个线程都判断instance为空，接下来就会得到两个实例了。这不是我们想要的单例。


接下来我们用加锁的方式来实现互斥，从而保证单例的实现。

[java] view plaincopyprint?

  1. //同步法懒汉式  
  2. public class Singleton {  
  3.       
  4.     //单例实例变量  
  5.     private static Singleton instance = null;  
  6.       
  7.     //私有化的构造方法，保证外部的类不能通过构造器来实例化  
  8.     private Singleton() {}  
  9.       
  10.     //获取单例对象实例  
  11.     public static synchronized  Singleton getInstance() {  
  12.           
  13.         if (instance == null) {   
  14.             instance = new Singleton();   
  15.         }  
  16.           
  17.         System.out.println("我是同步法懒汉式单例！");  
  18.         return instance;  
  19.     }  
  20. }  

加上synchronized后确实保证了线程安全，但是这样就是最好的方法吗？很显然它不是，因为这样一来每次调用getInstance()方法是都会被加锁，而我们只需要在第一次调用getInstance()的时候加锁就可以了。这显然影响了我们程序的性能。我们继续寻找更好的方法。

经过分析发现，只需要保证instance = new Singleton()是线程互斥就可以保证线程安全，所以就有了下面这个版本：

[java] view plaincopyprint?

  1. //双重锁定懒汉式  
  2. public class Singleton {  
  3.       
  4.     //单例实例变量  
  5.     private static Singleton instance = null;  
  6.       
  7.     //私有化的构造方法，保证外部的类不能通过构造器来实例化  
  8.     private Singleton() {}  
  9.       
  10.     //获取单例对象实例  
  11.     public static Singleton getInstance() {  
  12.         if (instance == null) {   
  13.             synchronized (Singleton.class) {  
  14.                 if (instance == null) {   
  15.                     instance = new Singleton();   
  16.                 }  
  17.             }  
  18.         }  
  19.         System.out.println("我是双重锁定懒汉式单例！");  
  20.         return instance;  
  21.     }  
  22. }  

这次看起来既解决了线程安全问题，又不至于每次调用getInstance()都会加锁导致降低性能。看起来是一个完美的解决方案，事实上是这样的吗？

很遗憾，事实并非我们想的那么完美。java平台内存模型中有一个叫“无序写”（out-of-order writes）的机制。正是这个机制导致了双重检查加锁方法的失效。这个问题的关键在上面代码上的第5行：instance = new Singleton(); 这行其实做了两个事情：1、调用构造方法，创建了一个实例。2、把这个实例赋值给instance这个实例变量。可问题就是，这两步jvm是不保证顺序的。也就是说。可能在调用构造方法之前，instance已经被设置为非空了。下面我们一起来分析一下：


假设有两个线程A、B

1、线程A进入getInstance()方法。

2、因为此时instance为空，所以线程A进入synchronized块。

3、线程A执行 instance = new Singleton(); 把实例变量instance设置成了非空。（注意，是在调用构造方法之前。）

4、线程A退出，线程B进入。

5、线程B检查instance是否为空，此时不为空（第三步的时候被线程A设置成了非空）。线程B返回instance的引用。（问题出现了，这时instance的引用并不是Singleton的实例，因为没有调用构造方法。） 

6、线程B退出，线程A进入。

7、线程A继续调用构造方法，完成instance的初始化，再返回。 


难道就没有一个好方法了吗？好的方法肯定是有的，我们继续探索！

[java] view plaincopyprint?

  1. //解决无序写问题懒汉式  
  2. public class Singleton {  
  3.       
  4.     //单例实例变量  
  5.     private static Singleton instance = null;  
  6.       
  7.     //私有化的构造方法，保证外部的类不能通过构造器来实例化  
  8.     private Singleton() {}  
  9.       
  10.     //获取单例对象实例  
  11.     public static Singleton getInstance() {  
  12.         if (instance == null) {   
  13.             synchronized (Singleton.class) {                  //1  
  14.                 Singleton temp = instance;                //2  
  15.                 if (temp == null) {  
  16.                     synchronized (Singleton.class) {  //3   
  17.                         temp = new Singleton();   //4      
  18.                     }  
  19.                     instance = temp;                  //5        
返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞