双重检查锁定与单例模式

转载 2016年05月31日 16:56:11

转自:http://blog.csdn.net/applepie1/article/details/7265756

单例创建模式是一个通用的编程习语。和多线程一起使用时,必需使用某种类型的同步。在努力创建更有效的代码时,Java 程序员们创建了双重检查锁定习语,将其和单例创建模式一起使用,从而限制同步代码量。然而,由于一些不太常见的 Java 内存模型细节的原因,并不能保证这个双重检查锁定习语有效。它偶尔会失败,而不是总失败。此外,它失败的原因并不明显,还包含 Java 内存模型的一些隐秘细节。这些事实将导致代码失败,原因是双重检查锁定难于跟踪。在本文余下的部分里,我们将详细介绍双重检查锁定习语,从而理解它在何处失效。

要理解双重检查锁定习语是从哪里起源的,就必须理解通用单例创建习语,如清单 1 中的阐释:

[java] view plain copy
  1. 清单 1. 单例创建习语  
  2.   
  3.                   
  4.   
  5. import java.util.*;  
  6. class Singleton  
  7. {  
  8.   private static Singleton instance;  
  9.   private Vector v;  
  10.   private boolean inUse;  
  11.   
  12.   private Singleton()  
  13.   {  
  14.     v = new Vector();  
  15.     v.addElement(new Object());  
  16.     inUse = true;  
  17.   }  
  18.   
  19.   public static Singleton getInstance()  
  20.   {  
  21.     if (instance == null)          //1  
  22.       instance = new Singleton();  //2  
  23.     return instance;               //3  
  24.   }  
  25. }  

此类的设计确保只创建一个 Singleton 对象。构造函数被声明为 privategetInstance() 方法只创建一个对象。这个实现适合于单线程程序。然而,当引入多线程时,就必须通过同步来保护 getInstance() 方法。如果不保护getInstance() 方法,则可能返回 Singleton 对象的两个不同的实例。假设两个线程并发调用 getInstance() 方法并且按以下顺序执行调用:

  1. 线程 1 调用 getInstance() 方法并决定 instance 在 //1 处为 null

  2. 线程 1 进入 if 代码块,但在执行 //2 处的代码行时被线程 2 预占。

  3. 线程 2 调用 getInstance() 方法并在 //1 处决定 instance 为 null

  4. 线程 2 进入 if 代码块并创建一个新的 Singleton 对象并在 //2 处将变量 instance 分配给这个新对象。

  5. 线程 2 在 //3 处返回 Singleton 对象引用。

  6. 线程 2 被线程 1 预占。 

  7. 线程 1 在它停止的地方启动,并执行 //2 代码行,这导致创建另一个 Singleton 对象。

  8. 线程 1 在 //3 处返回这个对象。

结果是 getInstance() 方法创建了两个 Singleton 对象,而它本该只创建一个对象。通过同步 getInstance() 方法从而在同一时间只允许一个线程执行代码,这个问题得以改正,如清单 2 所示:

[java] view plain copy
  1. 清单 2. 线程安全的 getInstance() 方法  
  2.   
  3.                   
  4.   
  5. public static synchronized Singleton getInstance()  
  6. {  
  7.   if (instance == null)          //1  
  8.     instance = new Singleton();  //2  
  9.   return instance;               //3  
  10. }  

清单 2 中的代码针对多线程访问 getInstance() 方法运行得很好。然而,当分析这段代码时,您会意识到只有在第一次调用方法时才需要同步。由于只有第一次调用执行了 //2 处的代码,而只有此行代码需要同步,因此就无需对后续调用使用同步。所有其他调用用于决定 instance 是非 null 的,并将其返回。多线程能够安全并发地执行除第一次调用外的所有调用。尽管如此,由于该方法是 synchronized 的,需要为该方法的每一次调用付出同步的代价,即使只有第一次调用需要同步。

为使此方法更为有效,一个被称为双重检查锁定的习语就应运而生了。这个想法是为了避免对除第一次调用外的所有调用都实行同步的昂贵代价。同步的代价在不同的 JVM 间是不同的。在早期,代价相当高。随着更高级的 JVM 的出现,同步的代价降低了,但出入 synchronized 方法或块仍然有性能损失。不考虑 JVM 技术的进步,程序员们绝不想不必要地浪费处理时间。

因为只有清单 2 中的 //2 行需要同步,我们可以只将其包装到一个同步块中,如清单 3 所示:

[java] view plain copy
  1. 清单 3. getInstance() 方法  
  2.   
  3.                   
  4.   
  5. public static Singleton getInstance()  
  6. {  
  7.   if (instance == null)  
  8.   {  
  9.     synchronized(Singleton.class) {  
  10.       instance = new Singleton();  
  11.     }  
  12.   }  
  13.   return instance;  
  14. }  

清单 3 中的代码展示了用多线程加以说明的和清单 1 相同的问题。当 instance 为 null 时,两个线程可以并发地进入 if 语句内部。然后,一个线程进入 synchronized 块来初始化 instance,而另一个线程则被阻断。当第一个线程退出 synchronized 块时,等待着的线程进入并创建另一个 Singleton 对象。注意:当第二个线程进入synchronized 块时,它并没有检查 instance 是否非 null


双重检查锁定

为处理清单 3 中的问题,我们需要对 instance 进行第二次检查。这就是“双重检查锁定”名称的由来。将双重检查锁定习语应用到清单 3 的结果就是清单 4 。

[java] view plain copy
  1. 清单 4. 双重检查锁定示例  
  2.   
  3.                   
  4.   
  5. public static Singleton getInstance()  
  6. {  
  7.   if (instance == null)  
  8.   {  
  9.     synchronized(Singleton.class) {  //1  
  10.       if (instance == null)          //2  
  11.         instance = new Singleton();  //3  
  12.     }  
  13.   }  
  14.   return instance;  
  15. }  

双重检查锁定背后的理论是:在 //2 处的第二次检查使(如清单 3 中那样)创建两个不同的 Singleton 对象成为不可能。假设有下列事件序列:

  1. 线程 1 进入 getInstance() 方法。

  2. 由于 instance 为 null,线程 1 在 //1 处进入 synchronized 块。

  3. 线程 1 被线程 2 预占。

  4. 线程 2 进入 getInstance() 方法。

  5. 由于 instance 仍旧为 null,线程 2 试图获取 //1 处的锁。然而,由于线程 1 持有该锁,线程 2 在 //1 处阻塞。

  6. 线程 2 被线程 1 预占。

  7. 线程 1 执行,由于在 //2 处实例仍旧为 null,线程 1 还创建一个 Singleton 对象并将其引用赋值给instance

  8. 线程 1 退出 synchronized 块并从 getInstance() 方法返回实例。

  9. 线程 1 被线程 2 预占。

  10. 线程 2 获取 //1 处的锁并检查 instance 是否为 null

  11. 由于 instance 是非 null 的,并没有创建第二个 Singleton 对象,由线程 1 创建的对象被返回。

双重检查锁定背后的理论是完美的。不幸地是,现实完全不同。双重检查锁定的问题是:并不能保证它会在单处理器或多处理器计算机上顺利运行。

双重检查锁定失败的问题并不归咎于 JVM 中的实现 bug,而是归咎于 Java 平台内存模型。内存模型允许所谓的“无序写入”,这也是这些习语失败的一个主要原因。

双重检查锁定(double-checked locking)与单例模式

单例模式有如下实现方式:package com.zzj.pattern.singleton; public class Singleton { private static Singleton i...
  • zhangzeyuaaa
  • zhangzeyuaaa
  • 2015年01月13日 12:11
  • 5508

Java单例模式中双重检查锁的问题

单例创建模式是一个通用的编程习语。和多线程一起使用时,必需使用某种类型的同步。在努力创建更有效的代码时,Java 程序员们创建了双重检查锁定习语,将其和单例创建模式一起使用,从而限制同步代码量。然而,...
  • chenchaofuck1
  • chenchaofuck1
  • 2016年06月17日 19:16
  • 18455

双重检查锁定与延迟初始化

本来是看到多线程中关于安全发布的问题,然后想起来之前看过文章说双重检查锁定也不能解决安全发布的问题,但是不记得为什么了。于是,就去搜了一下,这篇转载的文章写的挺清楚的(本来还打算自己写)。 本文...
  • java_4_ever
  • java_4_ever
  • 2014年11月14日 13:49
  • 885

双重检查锁定(double-checked locking)与单例模式

出处:http://blog.csdn.net/zhangzeyuaaa/article/details/42673245 单例模式有如下实现方式: [java] view...
  • jiaoyongqing134
  • jiaoyongqing134
  • 2016年10月06日 17:09
  • 196

单例模式与双重检测

http://jiangzhengjun.iteye.com/blog/652440 首先要解释一下什么是延迟加载,延迟加载就是等到真真使用的时候才去创建实例,不用时不要去创建。   从速度和...
  • zhanghongzheng3213
  • zhanghongzheng3213
  • 2016年07月06日 15:10
  • 353

单例模式的双重检测

最近学习多线程 发现提到一个单例模式的l检测研究了一下确实发现很麻烦 写下来以备后用 1、饿汉式单例模式 所谓饿汉式就是不管原来有没有上来就新创建一个 不管肚子里面有没有先吃一个再说 public...
  • majun_guang
  • majun_guang
  • 2015年03月25日 23:37
  • 1604

C++和双重检查锁定模式(DCLP)的风险(转)

多线程其实就是指两个任务一前一后或者同时发生。 1 简介 当你在网上搜索设计模式的相关资料时,你一定会找到最常被提及的一个模式:单例模式(Singleton)。然而,当你尝试在项目中使用单例模式时...
  • tantexian
  • tantexian
  • 2016年02月18日 11:04
  • 1086

【C#】C#中单例的双重锁定模式

using System; using System.Collections.Generic; /// /// 适用于在多线程的情况下保证只有一个实例化对象的情况,例如银行的操作系统 /// na...
  • sinat_20559947
  • sinat_20559947
  • 2015年09月09日 10:11
  • 2959

双重检查加锁单例模式

双重检查加锁单例模式为什么失效,多线程下怎样实现安全的单例模式。了解Java内存模型,同步的语义...
  • u013673976
  • u013673976
  • 2015年02月14日 20:15
  • 1299

单例模式的双层锁原理

为什么要在多线程中创建单例模式的时候要进行双重锁定?先回顾一下双重锁定的代码块。 public class SingleTon { private static SingleTo...
  • nyist327
  • nyist327
  • 2015年10月21日 10:53
  • 3897
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:双重检查锁定与单例模式
举报原因:
原因补充:

(最多只允许输入30个字)