单例模式-双重检查加锁

(参考:http://www.cnblogs.com/java-my-life/archive/2012/03/31/2425631.html

双重检查加锁:
    (1)既实现线程安全,又能够使性能不受很大的影响。那么什么是“双重检查加锁”机制呢?
      (2)所谓“双重检查加锁”机制,指的是:并不是每次进入getInstance方法都需要同步,而是先不同步,进入方法后,先检查实例是否存在,如果不存在才进行下面的同步块,这是第一重检查,进入同步块过后,再次检查实例是否存在,如果不存在,就在同步的情况下创建一个实例,这是第二重检查。这样一来,就只需要同步一次了,从而减少了多次在同步情况下进行判断所浪费的时间。
   (3)“双重检查加锁”机制的实现会使用关键字volatile,它的意思是:被volatile修饰的变量的值,将不会被本地线程缓存,所有对该变量的读写都是直接操作共享内存,从而确保多个线程能正确的处理该变量。       (4)由于volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化,所以运行效率并不是很高。因此一般建议,没有特别的需要,不要使用。也就是说,虽然可以使用“双重检查加锁”机制来实现线程安全的单例,但并不建议大量采用,可以根据情况来选用。
/**
 * Project Name:DesignPatterns
 * File Name:Single.java
 * Package Name:com.louis.singlePattern
 * Date:2017年9月26日下午9:24:31
 * Copyright (c) 2017, [email protected] All Rights Reserved.
 *
*/

package com.louis.singlePattern;
/**
 * ClassName:Single
 * Function: TODO ADD FUNCTION.
 * Reason:     TODO ADD REASON.
 * Date:     2017年9月26日 下午9:24:31
 * @author   michael
 * @version
 * @since    JDK 1.7
 * @see
 */
public class Single {
    public volatile static  Single instanceSingle = null;

    private Single(){}

    public static Single getInstance(){
        //首先检查实例存不存在
        if(instanceSingle == null){
            //同步块,线程安全的创建实例
            synchronized (Single.class) {
                //再次检查实例是否真的存在,如果不存在则真正创建实例
                if(instanceSingle == null){
                    instanceSingle = new Single();
                }
            }
        }
        return instanceSingle ;
    }

}
时间: 2024-11-05 23:07:29

单例模式-双重检查加锁的相关文章

java单例模式(双重检查加锁)的原因

public class Singleton{ private static Singleton instance = null;//是否是final的不重要,因为最多只可能实例化一次. private Singleton(){} public static Singleton getInstance(){ if(instance == null){ //双重检查加锁,只有在第一次实例化时,才启用同步机制,提高了性能. synchronized(Singleton.Class){ if(inst

糟糕的双重检查加锁(DCL)

在Java并发编程时,同步都会存在着巨大的性能开销,因此,人们使用了很多的技巧来降低同步的影响,这其中有一些技巧很好,但是也有一些技巧存在一些缺陷,下面要结束的双重检查加锁(DCL)就是有缺陷的一类. 由于早期的JVM在性能上存在一些有待优化的地方,因此在并发编程中,延迟初始化经常被用来降低程序的开销.编写正确的延迟初始化需要使用同步,但是直接在初始化之前使用同步会对性能产生影响.所以一些人就提出了双重检查加锁,并声称能够解决这个矛盾.如图所示就是双重检查加锁的代码. 上图代码中,对Resour

双重检查锁定的单例模式和延迟初始化

有时候需要推迟一些高开销的对象初始化操作,并且只有在使用这些对象时才进行初始化.此时,常用的可能就是延迟初始化,例如:懒汉式单例模式,但是要正确的实现线程安全的延迟初始化需要一些技巧,下面是非线程安全的示例代码: public class UnsafeLazyInit { private static Instance instance ; public static Instance getInstance(){ if(instance == null ) //1.A线程执行 instance

双重检查锁单例模式为什么要用volatile关键字?

前言 从Java内存模型出发,结合并发编程中的原子性.可见性.有序性三个角度分析volatile所起的作用,并从汇编角度大致说了volatile的原理,说明了该关键字的应用场景:在这补充一点,分析下volatile是怎么在单例模式中避免双检锁出现的问题的. 并发编程的3个条件 1.原子性:要实现原子性方式较多,可用synchronized.lock加锁,AtomicInteger等,但volatile关键字是无法保证原子性的:2.可见性:要实现可见性,也可用synchronized.lock,v

线程安全的单例模式及双重检查锁—个人理解

在web应用中服务器面临的是大量的访问请求,免不了多线程程序,但是有时候,我们希望在多线程应用中的某一个类只能新建一个对象的时候,就会遇到问题. 首先考虑单线程,如果要求只能新建一个对象,那么构造函数我们要设为private.简单的想法: class singleton{ private singleton(){ //..... } private static singleton instance; public static singleton getinstance(){ if(insta

单例模式中用volatile和synchronized来满足双重检查锁机制

背景:我们在实现单例模式的时候往往会忽略掉多线程的情况,就是写的代码在单线程的情况下是没问题的,但是一碰到多个线程的时候,由于代码没写好,就会引发很多问题,而且这些问题都是很隐蔽和很难排查的. 例子1:没有volatile修饰的uniqueInstance public class Singleton { private static Singleton uniqueInstance; private Singleton(){ } public static Singleton getInsta

单例模式的两种实现方式对比:DCL (double check idiom)双重检查 和 lazy initialization holder class(静态内部类)

首先这两种方式都是延迟初始化机制,就是当要用到的时候再去初始化. 但是Effective Java书中说过:除非绝对必要,否则就不要这么做. 1. DCL (double checked locking)双重检查: 如果出于性能的考虑而需要对实例域(注意这个属性并没有被static修饰)使用延迟初始化,就使用双重检查模式 public class Singleton { private volatile Singleton uniqueInstance; private Singleton(){

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

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

单例模式中 的 双重检查锁 概念与用法

public class Singleton { //私有的 静态的 本类属性 private volatile static Singleton _instance; //私有化构造器 private Singleton() {} /* * 1st version: creates multiple instance if two thread access * this method simultaneouslyX */ public static Singleton getInstance