Java单例的实现和分析（双重校验锁的破坏）

最新推荐文章于 2025-03-10 23:45:00 发布
最新推荐文章于 2025-03-10 23:45:00 发布
阅读量699 收藏 2
点赞数
分类专栏： java 设计模式 手撕代码 文章标签： java 设计模式 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq374461948/article/details/106181213
版权
本文深入探讨了Java单例模式的实现方式，包括饿汉式、懒汉式和双重校验锁（DCL）。详细分析了DCL的线程安全性和使用volatile关键字的原因。此外，还讨论了如何通过反射破坏单例模式，并提出了通过信号量防止破坏的解决方案。最后，介绍了使用枚举实现单例模式的安全性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

设计模式：单例模式

1.基本概念

目的： 保证类在内存中只有一个对象，可以直接访问，不需要实例化该类的对象
注意：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
使用场景：
1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
注意事项： getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

2.代码实现

2.1.饿汉式（即时创建对象）

这种方式比较常用，但容易产生垃圾对象。空间换时间。
是否多线程安全： 是
实现难度： 易
优点： 没有加锁，执行效率会提高。
缺点： 类加载时就初始化，浪费内存。

public class Main {
    public static void main(String[] args) {
        //通过方法获得唯一对象
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        //判断是否为唯一对象
        System.out.println(s1 == s2);//运行结果为true
    }
}
class Singleton {
    //1.私有构造方法，其他类不能访问该构造方法
    private Singleton() {}
    //2.创建本类对象
    private static Singleton s = new Singleton();
    //3.对外提供公共的访问方法
    public static Singleton getInstance() {//获取实例
        return s;
    }
}

2.2.懒汉式（使用时才创建对象）

2.2.1.线程不安全的懒汉式

这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式，不要求线程安全，在多线程不能正常工作。
是否多线程安全： 否
实现难度： 易

public class Main {
    public static void main(String[] args) {
    	//通过方法获得唯一对象
        SingletonLazy s1 = SingletonLazy.getInstance();
        SingletonLazy s2 = SingletonLazy.getInstance();
        System.out.println(s1 == s2);
    }
}
class SingletonLazy {
    //1.私有构造方法，其他类不能访问该构造方法
    private SingletonLazy() {}
    //2.声明一个引用
    private static SingletonLazy s;
    //3.对外提供公共的访问方法
    public static SingletonLazy  getInstance() {//获取实例
        //当没有对象时，进行创建
        if(s==null){
            s = new SingletonLazy();
        }
        return s;
    }
}

2.2.2.线程安全的懒汉式

这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
是否多线程安全： 是
实现难度： 易
优点： 第一次调用才初始化，避免内存浪费。
缺点： 必须加锁 synchronized 才能保证单例，但加锁会影响效率。

public class Main {
    public static void main(String[] args) {
    	//通过方法获得唯一对象
        SingletonLazy s1 = SingletonLazy.getInstance();
        SingletonLazy s2 = SingletonLazy.getInstance();
        System.out.println(s1 == s2);
    }
}
class SingletonLazy {
    //1.私有构造方法，其他类不能访问该构造方法
    private SingletonLazy() {}
    //2.声明一个引用
    private static SingletonLazy s;
    //3.对外提供公共的访问方法（使用synchronized锁，防止线程抢占）
    public static synchronized SingletonLazy  getInstance() {//获取实例
        //当没有对象时，进行创建
        if(s==null){
            s = new SingletonLazy();
        }
        return s;
    }
}

2.3.final实现方式（了解）

通过final关键字，实现对象在创建之后不可被更改。

public class Main {
    public static void main(String[] args) {
		//获得唯一对象
        Singletonfinal s1 = Singletonfinal.s;
        Singletonfinal s2 = Singletonfinal.s;
        System.out.println(s1 == s2);//结果为true
    }
}
class Singletonfinal{
    //1.私有构造方法，其他类不能访问该构造方法
    private Singletonfinal() {}
    //2.声明一个引用，final表示了地址不可被修改
    public static final Singletonfinal s = new Singletonfinal();
}

3.双重校验锁（DCL，即double-checked locking）

3.1.DCL代码实现

是否 Lazy 初始化： 是
是否多线程安全： 是
实现难度： 较复杂
描述： 这种方式采用双锁机制，安全且在多线程情况下能保持高性能。getInstance() 的性能对应用程序很关键。

public class Main {
    public static void main(String[] args) {
        SingletonDCL s1 = SingletonDCL.getInstance();
        SingletonDCL s2 = SingletonDCL.getInstance();
        System.out.println(s1 == s2);//结果是true
    }
}
class SingletonDCL {
    //1.构造私有方法
    private SingletonDCL() {}
    //2.懒汉式Lazy初始化，使用volatile可以保证可见性，也禁止指令重排序
    private volatile static SingletonDCL singletonDCL;
    //3.提供外部获得实例的方法
    public static SingletonDCL getInstance() {
        //如果实例未创建,第一重
        if (singletonDCL == null)
            synchronized (SingletonDCL.class) {//通过字节码，反射机制获得对象，并上锁
                //加上锁后再次判断，第二重
                if (singletonDCL == null) {
                    singletonDCL = new SingletonDCL();
                }
            }
        return singletonDCL;//返回对象
    }
}

3.2.使用volatile的原因（禁止指令重排序）

指令重排序： 编译器优化的重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
例如：

 singletonDCL = new SingletonDCL();//实例化对象这行代码

这行代码实际上可以分解成三个步骤：
1.分配内存空间。
2.初始化对象。
3.将对象指向刚分配的内存空间。

但是有些编译器因为性能的原因，可能会改变2和3的顺序，就成了：
1.分配内存空间。
2.将对象指向刚分配的内存空间。
3.初始化对象。

在不使用volatile且发生重排序的情况下，调用顺序如下

线程一线程二
检查到singletonDCL为null-
获取锁-
再次检查到singletonDCL为null-
为singletonDCL分配内存空间-
将singletonDCL指向内存空间-
-检查到singletonDCL不为空
-访问singletonDCL（此时线程一还未初始化完成对象）
初始化singletonDCL-

在这种情况下，在线程二访问singletonDCL时，访问的是一个初始化未完成的对象。

4.如何通过反射破坏双重校验锁（抬杠）

4.1.1.通过反射无视私有构造器创建对象

public class Main {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        SingletonDCL s1 = SingletonDCL.getInstance();
        SingletonDCL s2 = SingletonDCL.getInstance();
        System.out.println(s1);
        System.out.println(s2);
       //---------------以下为添加的部分，SingletonDCL部分未改动--------------------
        //通过字节码，获得SingletonDCL的空参构造器
        Constructor<SingletonDCL> declaredConstructor = SingletonDCL.class.getDeclaredConstructor(null);
        //无视了私有的构造器
        declaredConstructor.setAccessible(true);
        //通过反射创建SingletonDCL对象
        SingletonDCL s3 = declaredConstructor.newInstance();
        //输出对象
        System.out.println(s3);
    }
}
class SingletonDCL {
    //1.构造私有方法
    private SingletonDCL() {}
    //2.懒汉式Lazy初始化，使用volatile可以保证可见性，也禁止指令重排序
    private volatile static SingletonDCL singletonDCL;
    //3.提供外部获得实例的方法
    public static SingletonDCL getInstance() {
        //如果实例未创建,第一重
        if (singletonDCL == null)
            synchronized (SingletonDCL.class) {//通过字节码，反射机制获得对象，并上锁
                //加上锁后再次判断，第二重
                if (singletonDCL == null) {
                    singletonDCL = new SingletonDCL();
                }
            }
        return singletonDCL;//返回对象
    }
}

运行结果：可见s1，s2为同一个对象，通过反射走对象空构造器创建的s3为不同的对象。
在这里插入图片描述

4.1.2.如何防止通过4.1.1反射机制创建对象

思路：如果对象已经走getInstance()进行创建，则可以在空构造器中加入对象判断，防止通过反射再次创建。

public class Main {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        SingletonDCL s1 = SingletonDCL.getInstance();
        SingletonDCL s2 = SingletonDCL.getInstance();
        System.out.println(s1);
        System.out.println(s2);
        //通过字节码，获得SingletonDCL的空参构造器
        Constructor<SingletonDCL> declaredConstructor = SingletonDCL.class.getDeclaredConstructor(null);
        //无视了私有的构造器
        declaredConstructor.setAccessible(true);
        //通过反射创建对象
        SingletonDCL s3 = declaredConstructor.newInstance();
        System.out.println(s3);
    }
}
class SingletonDCL {
    //1.构造私有方法
    private SingletonDCL() {
        synchronized (SingletonDCL.class){
       //---------------以下为添加的部分，增加第三重检测--------------------
            //第三重检测，如果对象singletonDCL已被创建，则可认为有人想通过反射进行创建
            if(singletonDCL!=null){
                throw new RuntimeException("使用反射创建对象失败");
            }
        }
    }
    //2.懒汉式Lazy初始化，使用volatile可以保证可见性，也禁止指令重排序
    private volatile static SingletonDCL singletonDCL;
    //3.提供外部获得实例的方法
    public static SingletonDCL getInstance() {
        //如果实例未创建,第一重
        if (singletonDCL == null)
            synchronized (SingletonDCL.class) {//通过字节码，反射机制获得对象，并上锁
                //加上锁后再次判断，第二重
                if (singletonDCL == null) {
                    singletonDCL = new SingletonDCL();
                }
            }
        return singletonDCL;//返回对象
    }
}

运行结果是这样的，原因是在一开始getInstance()的时候已经存在了singletonDCL对象，在第三重检测的时候，发现对象已经创建，所以就会走Exception。
在这里插入图片描述

4.1.3.使用多次反射破坏双重校验锁（杠到底）

在4.1.2的方法中，第三重校验能成功，是因为在一开始走了getInstance()方法，已经创建了singletonDCL对象，所以通过反射走空构造器的时候会失败。但是如果只用反射创建对象，singletonDCL对象并没有存储，得到的依旧是非单例的结果。

public class Main {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //通过字节码，获得SingletonDCL的空参构造器
        Constructor<SingletonDCL> declaredConstructor = SingletonDCL.class.getDeclaredConstructor(null);
        //无视了私有的构造器
        declaredConstructor.setAccessible(true);
        //通过反射创建对象
        SingletonDCL s3 = declaredConstructor.newInstance();
        SingletonDCL s4 = declaredConstructor.newInstance();
        System.out.println(s3);
        System.out.println(s4);
    }
}
class SingletonDCL {

    //1.构造私有方法
    private SingletonDCL() {
        synchronized (SingletonDCL.class){
            //第三重检测，如果对象singletonDCL已被创建，则可认为有人想通过反射进行创建
            if(singletonDCL!=null){
                throw new RuntimeException("使用反射创建对象失败");
            }
        }
    }
    //2.懒汉式Lazy初始化，使用volatile可以保证可见性，也禁止指令重排序
    private volatile static SingletonDCL singletonDCL;
    //3.提供外部获得实例的方法
    public static SingletonDCL getInstance() {
        //如果实例未创建,第一重
        if (singletonDCL == null)
            synchronized (SingletonDCL.class) {//通过字节码，反射机制获得对象，并上锁
                //加上锁后再次判断，第二重
                if (singletonDCL == null) {
                    singletonDCL = new SingletonDCL();
                }
            }
        return singletonDCL;//返回对象
    }
}

运行结果：通过反射创建的s3，s4
在这里插入图片描述

4.1.4.通过信号量保证单例对象只创建一次

public class Main {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //通过字节码，获得SingletonDCL的空参构造器
        Constructor<SingletonDCL> declaredConstructor = SingletonDCL.class.getDeclaredConstructor(null);
        //无视了私有的构造器
        declaredConstructor.setAccessible(true);
        //通过反射创建对象
        SingletonDCL s3 = declaredConstructor.newInstance();
        System.out.println(s3);
        SingletonDCL s4 = declaredConstructor.newInstance();
        System.out.println(s4);
    }
}
class SingletonDCL {
//---------------以下为添加的部分--------------------
   //定义一个对象是否创建的判断信号
    private static boolean charge= false;

    //1.构造私有方法
    private SingletonDCL() {
        System.out.println("走空构造器");
        synchronized (SingletonDCL.class){
            //---------------以下为添加的部分--------------------
            //无论走反射或者是get方法，创建一次对象之后，此信号就会置为true
            if (charge ==false){
                charge =true;
            }else {
                throw new RuntimeException("使用反射创建对象失败");
            }
        }

    }
    //2.懒汉式Lazy初始化，使用volatile可以保证可见性，也禁止指令重排序
    private volatile static SingletonDCL singletonDCL;
    //3.提供外部获得实例的方法
    public static SingletonDCL getInstance() {
        //如果实例未创建,第一重
        if (singletonDCL == null)
            synchronized (SingletonDCL.class) {//通过字节码，反射机制获得对象，并上锁
                //加上锁后再次判断，第二重
                if (singletonDCL == null) {
                    singletonDCL = new SingletonDCL();
                }
            }
        return singletonDCL;//返回对象
    }
}

运行结果：在第二次走空构造器的时候，由于charge为true，所以走else报错。
在这里插入图片描述

5.通过枚举实现单例模式

枚举是一种自带单例模式的类型，具体实现可以点进源码了解。

public enum Singleton {
    //仅枚举INSTANCE
    INSTANCE;
}
class Main2{
    public static void main(String[] args) {
        System.out.println(Singleton.INSTANCE);
        System.out.println(Singleton.INSTANCE);
    }
}

运行结果：显而易见，只能为单例
在这里插入图片描述

6.总结

在4.1.4.的方法可以通过反射破坏私有，获得charge变量，将其值改为false再次进行对象创建。因此看来似乎并没有绝对安全的代码。单例实现过程的话可以考虑看看枚举类型->enum的源码。另一方面，反序列化也可以破坏双重校验锁的单例实现。可谓道高一尺魔高一丈。

Java 单例模式的双重检测
TechChamp的博客
09-29 284
然而，需要注意的是，双重检测只在Java 5及以上版本中才能正常工作，因为在Java 5之前的版本中，volatile关键字的语义不够强大，可能会导致双重检测的失效。另外需要注意的是，双重检测中的同步块只在instance为null时才会执行，一旦instance被实例化，后续的调用将不再进入同步块，从而提高了性能。在上述示例中，通过调用Singleton类的getInstance()方法来获取Singleton实例，并可以在后续的代码中使用该实例进行其他操作。
Java单例模式 双重校验锁 为何两次if判断？
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
12-28 3389
内层判断：如果内层不加if判断，就会实例化多次，这是显而易见的，这就违背了单例模式的单例二字。 外层判断：试图想想一种情况，当线程1走完了内层判断，对象实例化了，线程3也调用了getInstace函数，如果没有加外层的判断线程3还是要继续等待线程2的完成，而加上外层判断，就不需要等待了，直接返回了实例化的对象。 我的理解：外层的判断是为了提高效率【不必synchronized等待】，里层的判断就是第一次实例化需要。 转自：https://blog.youkuaiyun.com/weixin_38983929/..
单例模式
Smallhorn的专栏
04-10 743
单例创建模式是一个通用的编程习语。和多线程一起使用时，必需使用某种类型的同步。在努力创建更有效的代码时，Java 程序员们创建了双重检查锁定习语，将其和单例创建模式一起使用，从而限制同步代码量。然而，由于一些不太常见的 Java 内存模型细节的原因，并不能保证这个双重检查锁定习语有效。它偶尔会失败，而不是总失败。此外，它失败的原因并不明显，还包含 Java 内存模型的一些隐秘细节。这些事实将导
单例模式-双重检查锁定
最新发布
m0_63199171的博客
03-10 468
由于可能存在多个线程同时进入第一层检查的情况，当第一个线程进入同步代码块并创建了单例对象后，其他线程可能还在等待进入同步代码块。这是因为不同类加载器加载的类被认为是不同的类，即使它们的类名相同。在单例对象创建之后，直接返回单例对象，避免了同步操作，提高了效率。方法时，只有一个线程可以进入同步代码块，其他线程必须等待当前线程执行完同步代码块后才能进入。方法时都进行同步操作，效率较低，尤其是当单例对象已经创建后，每次调用仍然需要同步。，说明单例对象尚未创建，此时创建单例对象并将其赋值给。
Java单例---双重锁校验
weixin_44378050的博客
10-08 226
双重锁校验单例 什么是单例模式？ 单例保证一个对象JVM中只能有一个实例 /** * 双重锁校验的单例 */ public class DoubleLock implements Serializable{ public static volatile DoubleLock doubleLock = null;//volatile防止指令重排序，内存可见 //(缓存中的变化及时刷到主存，并且其他的内存失效，必须从主存获取) private DoubleLock(){
双重检验锁方式实现单例模式
qq_63837759的博客
05-06 1521
正常步骤是1->2->3，但是JVM具有指令重排序的特性，在单线程下是不会存在问题的，但是在多线程下，会导致一个线程拿到还没有进行初始化的实例，例如线程1执行了1->3，然后线程二获取这个实例，发现不为空，拿到但是结果是没有初始化的。根据输出以及当前创建的对象，我们可以看到他创建了不同的对象，所以，为了解决这个方法，我们在创建对象的时候使用。其实这种实现方式也不是完美的，因为Java中那可是存在反射的，他就可以破坏对象的单例！你写的代码------------------>JIT优化之后的代码。
双重检查加锁单例模式
Mosquito_2的博客
02-23 441
双重检查加锁单例模式 先列一段代码 package cn.xpu.lw.test; public class Singleton { private static volatile Singleton singleton = null; private Singleton() { } public static Singleton getInstance(){ //第一次校验singleton是否为空 if(singleton==nul
java实现单例模式-双重校验锁模式（线程安全）
06-14
双重校验锁模式结合了懒汉模式和饿汉模式的优点，既实现了延迟加载，又保证了线程安全。你可以根据需求选择合适的单例模式实现方式。
java单例模式懒汉式 双重校验 关键字volatile
zhzjn的博客
10-11 1053
Volatile关键字的作用主要有如下两个：1.线程的可见性：当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。2.顺序一致性：禁止指令重排序。不保证原子性。
Java单例模式 双重校验锁 为啥要用volatile修饰
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
12-28 1488
public class Single { private static volatile Single single; public static Single getSingle(){ if (single==null){ synchronized (Single.class){ if (single==null){ single=new Single(); } } } return null; } } 因为如果不用volatile修饰的话，在 single=new Sing.
Java单例模式 双重校验锁 2021
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
01-29 317
package com.company; /** * @Author you guess * @Date 2021/1/29 09:32 * @Version 1.0 * @Desc 懒汉式 双重校验锁 */ public class SingletonTest { //变量私有 private volatile static SingletonTest instance = null;//用volatile static 修饰 //构造方法私有 priva.
//双重校验锁实现单例
weixin_42714605的博客
03-24 117
//双重校验锁实现单例 public class synchronizedDemo { //volatile 禁止jvm重排 保证内存的可见性 private volatile static synchronizedDemo uniqueIntance; //private 构造函数私有化 private synchronizedDemo(){ } private static synchr...
双重校验锁实现单例模式
Small_Pang的博客
08-18 489
1、先上代码： public class Singleton { private static volatile Singleton instance = null; private Singleton() {} public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (
双重校验锁实现单例对象
baihehaitangyijiu的博客
04-13 284
双重校验锁实现单例对象 第一个判断if (uniqueInstance == null)， 可以提高效率，如果直接在方法上加锁，那么线程得到已有的单例对象也会阻塞别的线程。如果单例对象不为空，直接返回就好了，不用加锁。 第二个判断if (uniqueInstance == null)，进一步确保在单例对象为空的情况下才生成单例对象。 第一个synchronize锁，保证在生成单例对象的时候只会有一...
Java 双重检验锁实现单例模式
siriusol的博客
02-18 689
双重校验锁实现对象单例（线程安全） public class Singleton { private volatile static Singleton singleton; private Singleton() {} public static Singleton getInstance() { if (singleton == null) { ...
双重检查锁实现单例
weixin_30808253的博客
08-10 85
public class Single { private volatile static Single single; private Single() { }; public static Single getSingle() { if (single == null) { synchronized (Single.class) { if (single == nul...
双重校验锁实现对象单例（线程安全）
qq_45887180的博客
09-20 200
双重校验锁实现对象单例（线程安全） public class Singleton { private volatile static Singleton uniqueInstance; private Singleton() { } public static Singleton getUniqueInstance() { *//先判断对象是否已经实例过，没有实例化过才进入加锁代码* if (uniqueInstance ==
双重校验锁优化的懒汉式单例模式详解与实现
本文档探讨了Java中的单例模式实现，重点介绍了一种称为"双重校验锁懒汉式加强"的方法。单例模式是一种常用的软件设计模式，其目标是确保一个类在整个程序运行期间只有一个实例，并提供全局访问点。这种模式常用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值