双重检查锁（DCL）问题

最新推荐文章于 2023-09-25 21:31:22 发布
最新推荐文章于 2023-09-25 21:31:22 发布
阅读量245 收藏 1
点赞数
原文链接：https://my.oschina.net/u/2331760/blog/3070889
版权

问题来源
以”懒汉式“单例模式为例（思想就是延迟高开销对象的初始化操作），代码如下。

这是一个普通的POJO：

package myTest;
import java.time.LocalDateTime;

/**
* <p>Title: DCLTestBean</p>  
* <p>Description: </p>  
* @author xiayuxuanmin  
* @date 2019年7月8日
 */
public class DCLTestBean {
    private String username;
    private Integer password;
 
    public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public Integer getPassword() {
		return password;
	}

	public void setPassword(Integer password) {
		this.password = password;
	}

	public DCLTestBean() {
        System.out.println(Thread.currentThread().getName()+"~~~~~"+LocalDateTime.now()+"  |DCLTestBean初始化了。");
    }
}


”懒汉式“单例：

package myTest;

/**
* <p>Title: TestDCLDemo3</p>  
* <p>Description: </p>  
* @author xiayuxuanmin
* @date 2019年7月8日
 */
public class DCLDemo3 {
    private static DCLTestBean instance;
    public static DCLTestBean getInstance(){
        if (instance==null){                  //第一行
            instance = new DCLTestBean();     //第二行
        }
        return instance;
    }
}


这个单例模式明显是线程不安全的，当多个线程调用时，他们可能都试图同时创建对象，或者可能最终获得对未完全初始化对象的引用。可以简单测试一下：

package myTest;

import java.util.concurrent.CountDownLatch;

/**
* <p>Title: TestDCLDemo3</p>  
* <p>Description: </p>  
* @author xiayuxuanmin
* @date 2019年7月8日
 */
public class TestDCLDemo3 {
	private static int count = 10;
	private static CountDownLatch countDownLatch = new CountDownLatch(count);
	private static DCLTestBean instance;
	
	public static DCLTestBean getInstance() {
		if(instance == null) {
			instance = new DCLTestBean();
		}
		return instance;
	}
	
	public static void main(String[] args) {
		for(int i = 0;i < count;i++) {
			new Thread(()-> {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				getInstance();
			},"thread-"+i).start();
			countDownLatch.countDown();
		}
	}
}

执行结果：

thread-6~~~~~2019-07-08T09:45:34.604  |DCLTestBean初始化了。
thread-7~~~~~2019-07-08T09:45:34.605  |DCLTestBean初始化了。
thread-9~~~~~2019-07-08T09:45:34.604  |DCLTestBean初始化了。
thread-1~~~~~2019-07-08T09:45:34.606  |DCLTestBean初始化了。
thread-4~~~~~2019-07-08T09:45:34.605  |DCLTestBean初始化了。
thread-8~~~~~2019-07-08T09:45:34.606  |DCLTestBean初始化了。
thread-0~~~~~2019-07-08T09:45:34.605  |DCLTestBean初始化了。
thread-5~~~~~2019-07-08T09:45:34.605  |DCLTestBean初始化了。
thread-3~~~~~2019-07-08T09:45:34.605  |DCLTestBean初始化了。
thread-2~~~~~2019-07-08T09:45:34.605  |DCLTestBean初始化了。

 

DCLTestBean初始化实例多次，这明显就违背了单例。

解决方法也很简单，直接加上synchronized即可：

package myTest;

import java.util.concurrent.CountDownLatch;

/**
* <p>Title: TestDCLDemo3</p>  
* <p>Description: </p>  
* @author xiayuxuanmin
* @date 2019年7月8日
 */
public class TestDCLDemo3 {
	private static int count = 10;
	private static CountDownLatch countDownLatch = new CountDownLatch(count);
	private static DCLTestBean instance;
	
	public static synchronized DCLTestBean getInstance() {
		if(instance == null) {
			instance = new DCLTestBean();
		}
		return instance;
	}
	
	public static void main(String[] args) {
		for(int i = 0;i < count;i++) {
			new Thread(()-> {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				getInstance();
			},"thread-"+i).start();
			countDownLatch.countDown();
		}
	}
}

执行结果:

thread-1~~~~~2019-07-08T09:50:21.112  |DCLTestBean初始化了。

 

但是在JDK1.6之前，synchronized属于重量级锁，如果getInstance()方法被多个线程频繁的调用，将会导致程序执行性能的下降。即只有在第一次调用getInstance()时将创建对象，并且在此期间只有少数尝试访问它的线程需要同步; 之后所有调用只获得对成员变量的引用。由于同步方法在某些极端情况下可以将性能降低100倍或更高，每次调用此方法时获取和释放锁的开销似乎都是不必要的：一旦初始化完成，获取并释放锁似乎没必要，于是下列方式优化这种情况：

检查变量是否已初始化（未获得锁定）。如果已初始化，请立即返回。
获得锁定。
仔细检查变量是否已经初始化：如果另一个线程首先获得了锁，它可能已经完成了初始化。如果是，则返回初始化变量。
否则，初始化并返回变量。
即双重检查锁，也就是DCL。

双重检查锁（DCL）
 

package myTest;

/**
* <p>Title: TestDCLDemo3</p>  
* <p>Description: </p>  
* @author xiayuxuanmin
* @date 2019年7月8日
 */
public class DCLDemo3 {
    private static DCLTestBean instance;
    
    public static DCLTestBean getInstance(){
        if (instance==null){                  //第一次检查
        	synchronized (DCLDemo3.class) {//同步锁
				if(instance==null) {   //第二次检查
					instance = new DCLTestBean();     
				}
			}
        }
        return instance;
    }
}

 

如上面代码所示，DCL本质上也就是减少了锁粒度，如果第一次检查instance不为null，那么就不需要执行下面的加锁和初始化操作。因此，可以大幅降低synchronized带来的性能开销。上面代码表面上看起来，似乎两全其美。多个线程试图在同一时间创建对象时，会通过加锁来保证只有一个线程能创建对象。在对象创建好之后，执行getInstance()方法将不需要获取锁，直接返回已创建好的对象。双重检查锁定看起来似乎很完美，但这是一个错误的优化！当线程进行第一次检查的时候，代码读取到instance不为null时，instance引用的对象有可能还没有完成初始化。

DCL问题分析
在上面代码中：

instance = new DCLTestBean();
这段代码可以分为如下三行伪代码：

memory = allocate(); //1.分配对象内存空间

ctorInstance(memory); //2.在内存空间初始化对象

instance = memory; //3.设置instance指向刚分配的内存地址

上面3行伪代码中的2和3之间，可能会被重排序（在一些JIT编译器上，这种重排序是真实发生的）。

memory = allocate(); //1.分配对象内存空间

instance = memory; //3.设置instance指向刚分配的内存地址

ctorInstance(memory); //2.在内存空间初始化对象

之前介绍过（https://blog.csdn.net/Dongguabai/article/details/82290776），指令重排序可以保证串行语义一致，但是没有义务保证多线程间的语义也一致。也就是说上面3行伪代码的2和3之间虽然被重排序了，但是是不影响串行语义的。但是在多线程并发执行的情况就可能出现：

也就是说一个线程可能读到尚未初始化的DCLTestBean，而这个instance的确是!=null的。

 

可以用过一段代码来“模拟”下这种情况：

package myTest;
import java.util.concurrent.TimeUnit;
 
/**
* <p>Title: DCLDemo</p>  
* <p>Description: </p>  
* @author xiayuxuanmin  
* @date 2019年7月8日
 */
public class DCLDemo {
 
    private static volatile DCLTestBean instance;
 
    public static DCLTestBean getInstance() throws InterruptedException {
        System.out.println(Thread.currentThread().getName()+"-----等待执行同步方法");
        if (instance == null) {
            synchronized (DCLDemo.class) {
            	System.out.println(Thread.currentThread().getName()+"进入同步方法");
                if (instance == null) {
                    instance = new DCLTestBean();
                    System.out.println(Thread.currentThread().getName()+"new 了");
                    //当前线程睡眠3秒
                    //该数值要大于main方法中的sleep,保证thread3在启动的时候,已经执行过new方法的线程正在睡眠状态
                    TimeUnit.SECONDS.sleep(3);
                    instance.setPassword(123);
                    instance.setUsername("zhangsan");
                }
            }
        }
        return instance;
    }
 
    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    DCLTestBean instance = DCLDemo.getInstance();
                    System.out.println(Thread.currentThread().getName()+"^^^^^"+instance.getUsername().toString());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
 
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        Thread thread3 = new Thread(runnable);
        thread1.start();
        thread2.start();
        //该代码的作用是让thread3延迟启动2秒(保证thread3在进入getInstance() 方法之后,在判断instance == null的时候,thread1 或者thread2已经执行过new()方法,并且执行new()方法的线程正处于睡眠状态)
        Thread.sleep(2000);
        thread3.start();
    }
}


运行结果为：

Thread-1-----等待执行同步方法
Thread-0-----等待执行同步方法
Thread-1进入同步方法
Thread-1~~~~~2019-07-08T10:00:40.881  |DCLTestBean初始化了。
Thread-1new 了
Thread-2-----等待执行同步方法
Exception in thread "Thread-2" java.lang.NullPointerException //出现空指针异常
	at myTest.DCLDemo$1.run(DCLDemo.java:39)
	at java.lang.Thread.run(Thread.java:748)
Thread-1^^^^^zhangsan
Thread-0进入同步方法
Thread-0^^^^^zhangsan

 

在知晓了问题发生的根源之后，我们可以想出两个办法来实现线程安全的延迟初始化。
1）不允许2和3重排序（在JDK 1.5后可以基于volatile来解决）；
2）允许2和3重排序，但不允许其他线程“看到”这个重排序（可以使用静态内部类解决）；

基于volatile的解决方案
很简单，只需要添加volatile关键字即可：

package myTest;

/**
* <p>Title: TestDCLDemo3</p>  
* <p>Description: </p>  
* @author xiayuxuanmin
* @date 2019年7月8日
 */
public class DCLDemo3 {
    private static volatile DCLTestBean instance;//这里加上volatile
    
    public static DCLTestBean getInstance(){
        if (instance==null){                  //第一次检查
        	synchronized (DCLDemo3.class) {//同步锁
				if(instance==null) {   //第二次检查
					instance = new DCLTestBean();     
				}
			}
        }
        return instance;
    }
}

这个解决方案需要JDK 5或更高版本（因为从JDK 5开始使用新的JSR-133内存模型规范，这个规范增强了volatile的语义）。
当声明对象的引用为volatile后，下图中的3行伪代码中的2和3之间的重排序，在多线程环境中将会被禁止。当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取变量。

时序图为：


 

转载于:https://my.oschina.net/u/2331760/blog/3070889

chetui2456
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java单例模式 双重校验锁 为何两次if判断？
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
12-28 3185
内层判断：如果内层不加if判断，就会实例化多次，这是显而易见的，这就违背了单例模式的单例二字。 外层判断：试图想想一种情况，当线程1走完了内层判断，对象实例化了，线程3也调用了getInstace函数，如果没有加外层的判断线程3还是要继续等待线程2的完成，而加上外层判断，就不需要等待了，直接返回了实例化的对象。 我的理解：外层的判断是为了提高效率【不必synchronized等待】，里层的判断就是第一次实例化需要。 转自：https://blog.csdn.net/weixin_38983929/..
java多线程之单例模式和其DCL问题
Song's Blog
04-28 1068
    首先在说明单例设计模式中的DCL问题之前我们首先看看实现单例设计模式的两种方式：饿汉式和懒汉式。     什么是饿汉式？     饿汉式就是不管你是否用的上，一开始就先初始化对象（也叫做提前初始化） 代码示例：   public class EagerInitialization{ private EagerInitialization() {} private...
Java并发编程——DCL问题
Java是世界上最好的语言
11-08 1099
单例模式中的DCL问题 我们都知道在程序执行过程中，java虚拟机为了速率，有可能会产生重排序。拿最普通的初始化一个实例来讲。他的过程如下： （1）分配内存； （2）初始化实例； （3）将实例指向该内存。 但是由于重排序的特性，可能最终的执行方式是1->3->2。如此就会产生，还没有将实例中的变量初始化完毕，就已经分配了内存。此时该实例已经不为null，但是其中的成员变量，还没有初始化为指定值。当别的线程调用时，就会返回错误的结果。 举个栗子，写一个单例模式中的双检查模式。 public cla
DCL锁双重检查；
xiaoyaolangwj的博客
02-07 1223
学习来源于：B站马士兵视频：《计算机底层原理》 DCL:Double check lock。 其本质是为了解决多线程中语句执行不确定性。 你也不知道当前其他线程进行到哪里，哪里都有可能。 比如在单例模式中，需要判断单例对象是否已经存在，if如果单例存在：则返回单例。否则else就去new一个单例。 这样做有一个问题：当涉及到多线程时，可能有多个线程同时来判断单例是否存在，此时，有两个甚至多个线程同时判断为不存在，则多个线程都会去创建单例。这样还是很多对象。 如何避免，首先考虑加锁，即判断单例
java中的DCL双重检查锁（double checked locking）
hjy930226173的博客
07-27 108
public class Singleton { private volatile static Singleton singleton; private Singleton() { } public Singleton getInstance() { if (null == singleton) { synchronized(this){ if (null == singleton) { sing.
双重检查锁
09-22
双重检查锁(Double-Checked Locking, DCL)是一种在多线程环境中用于实现懒加载(lazy loading)的设计模式。它通过两次检查来确定是否需要获取锁，从而避免不必要的同步操作，提高程序性能。然而，DCL的实现并不像表面...
java双重校验锁（DCL）
小白他表哥的博客
01-13 2485
获取线程安全的单例模式请看文末最后一段代码 先简单说下java对象的创建过程： 1.在堆内存中为对象分配内存空间 2.执行对象的构造方法初始化对象 3.对象引用指向堆内存中分配的内存地址 但是当我们编译的时候，编译器在生成汇编代码时候会对流程顺序进行优化（重排序），优化后的执行顺序不是我们可以控制的。重排序后在单线程的情况下是可以保证最后的结果是一致的 单线程里2和3虽然被重排序了，但是不影响串行语义 以”懒汉式“单例模式为例，多线程情况下2和3重排序后会导致出现多个对象的问题。 问题例举
什么是DCL双重检查锁
最新发布
11-06
DCL双重检查锁是指在加锁的前提下，先进行一次判断，如果单例对象已经存在，那么直接返回该对象，否则再进行加锁和判断，这样可以避免多个线程同时创建对象的问题，提高了效率。但是需要注意的是，在加锁完成后，...
Java双重检查加锁单例模式的详解
08-26
Java双重检查加锁单例模式是一种常用的单例模式实现方法，但是在多线程环境下，它存在一些问题。在这篇文章中，我们将探讨Java双重检查加锁单例模式的详解，包括它的优点和缺点，以及如何正确地使用它。 Java双重...
【单例模式】DCL的问题和解决方法
weixin_43260123的博客
02-10 343
https://www.jianshu.com/p/ca19c22e02f4
Java单例之DCL双重检查锁
Smartbbbb的博客
09-29 426
话不多说上代码！其中main函数是模仿多线程访问单例，打印对象的hashCode值来查看多线程环境下拿到的实例是不是同一个。 package com.kali.jvm.singleton; public class V1Singleton { private static final V1Singleton INSTANCE = new V1Singleton(); private V1Singleton(){} public static V1Singleton getI
正确使用双重检查锁(DCL)
chunshaihuo5061的博客
03-05 203
很多人熟知单例模式中有一种写法是使用双重检查锁实现的，但是在网上看到的例子基本上都不正确，有些写是正确，但没有很好解析，造成很多人没有真正理解。其中，典型错误写法是这样的： public class Resource { private static Resource resourc...
java单例模式的线程安全 JAVA多线程编程中的双重检查锁定（DCL单例（Double Check Lock））
wuyuanshun的博客
04-12 625
以上代码使用了双重检查锁，但是还是存在线程安全问题，因为可能会出现代码指令重排序。重排序其实出现在字节码层级。在字节码层级Object o=new Object();如果赋值和关联语句发生了代码重排序 ，及两句交换执行。就会出现先把对象关联到o，但是对象还没有初始化赋值。前加 volatile关键字【禁止指令重排序（CPU）】INVOKESPECIAL java/lang/Object. ()V 赋值。NEW java/lang/Object 申请内存。2.禁止指令重排序（CPU）
Java并发之双重检查锁DCL ☆☆☆☆☆
04stone37
03-28 470
问题分析问题：多线程情况下可能得到未被初始化的Singleton对象； 原因： synchronized代码块中的语句可能发生重排序；public class Singleton { private static Singleton singleton; private Singleton(){} public static Singleton getInstance(){
DCL详解
干嘛卷来卷去的博客
06-12 1777
在Java中，DCL通常指的是Double-Checked Locking（双重检查锁定）。DCL是一种用于多线程环境下懒加载单例对象的技术，它的基本思路是在对象还未被实例化时，先通过一次判空，避免了每次获取对象时都需要加锁的开销，从而提高了程序的性能。但是，在Java中实现DCL是比较容易出现问题的，因为Java的内存模型允许指令重排，可能会导致在多线程环境下DCL失效，从而创建出多个对象实例。
高并发下双重检测锁DCL指令重排问题剖析
日拱一卒无有尽，功不唐捐终入海
09-25 1054
双重检查锁定（Double-Checked Locking）是一种并发设计模式，该模式减少了同步的开销，提高了执行效率。该模式通过两次检查锁定，确保被检查的代码的线程安全性。在第一次检查中，如果发现变量不满足条件，才进行加锁操作。然后在锁定的区块内再进行一次检查，如果仍不满足条件，才进行相关操作。指令重排是为了提高处理器性能，允许编译器和处理器调整指令的执行顺序。一旦保证最终执行结果与代码顺序执行的结果一致，即使没有按照代码原有的顺序执行也不影响。volatile是Java提供的一种轻量级的同步机制。
单例模式-双重检查锁（DCL）和volatile 的应用
iiopsd的博客
06-22 378
单例模式-双重检查锁（DCL）延伸——volatile 的应用
深入理解DCL（双重检测锁）单例
qq_46054356的博客
03-11 1725
深入理解DCL（双重检测锁）单例 如果不使用双重检测锁我们可以直接使用synchronized关键字实现 // 懒汉式 public class Singleton { // 单例对象 private Singleton singleton = null; // 私有构造方法 private Singleton() { } // 获取单例 public static synchronized Singleton getSingleton() {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值