彻底玩转单例模式

最新推荐文章于 2024-04-29 10:00:53 发布
最新推荐文章于 2024-04-29 10:00:53 发布
阅读量398 收藏
点赞数
文章标签： 单例模式 java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bestandw1shes_lsy/article/details/121749231
版权

单例模式分为：

饿汉模式、懒汉模式、DCL懒汉式、静态内部类单例、枚举单例

本文逐一实现上述几种方式的单例模式，并且分析其在并发中、反射中可能出现的问题，然后对应问题给出解决方法。 

一.饿汉式

1. 代码如下：

public class Hungry {
    
    private Hungry(){

    }

    private static final Hungry hungry= new Hungry();

    public static Hungry getInstance(){
        return hungry;
    }
}

2. 问题分析：

public class Hungry {

    private static Byte[] bytes1 = new Byte[1024 * 1024];
    private static Byte[] bytes2 = new Byte[1024 * 1024];
    private static Byte[] bytes3 = new Byte[1024 * 1024];
    private static Byte[] bytes4 = new Byte[1024 * 1024];

    private Hungry(){

    }

    private static final Hungry hungry= new Hungry();

    public static Hungry getInstance(){
        return hungry;
    }
}

饿汉式单列模式在类被加载时就会实例化一个对象，此时如果类中出现上述 new Byte[] 的情况，开辟大量内存空间，但是又不使用它，就回消耗大量内存，可能造成资源浪费。

3.  解决方法：懒汉式单例模式。

二. 懒汉式

1. 代码如下：

public class LazyMan {

    private LazyMan(){

    }

    private static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if (lazyMan == null){
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }
}

2. 问题分析：

public class LazyMan {

    private LazyMan(){
        System.out.println(Thread.currentThread().getName());
    }

    private static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if (lazyMan == null){
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }

    // 多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10 ; i++) {
            new Thread(() -> {
                LazyMan.getInstance();
            }).start();
        }
    }
}

第一次执行结果：

Thread-0

第二次执行结果：

Thread-1
Thread-2
Thread-0

第三次执行结果：

Thread-0
Thread-1

偶尔成功，偶尔失败，每次结果都不一样，所以在单线程没问题，并发下懒汉式单例是有问题。

3. 解决方法：

(1) 加锁：

public class LazyMan {

    private LazyMan(){
        System.out.println(Thread.currentThread().getName());
    }

    private static LazyMan lazyMan;

    public static synchronized LazyMan getInstance(){
        if (lazyMan == null){
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }

    // 多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10 ; i++) {
            new Thread(() -> {
                LazyMan.getInstance();
            }).start();
        }
    }
}

使用同步锁锁住了整个方法，可以解决并发问题，但是会导致效率较低；

(2) DCL懒汉式单例模式。

三. DCL懒汉式(双重检测锁模式)

1. 代码如下：

public class LazyMan {

    private LazyMan(){
        System.out.println(Thread.currentThread().getName());
    }

    private static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if (lazyMan == null){
            synchronized (LazyMan.class){ // 保证当前类只有一个
                if (lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }

    // 多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10 ; i++) {
            new Thread(() -> {
                LazyMan.getInstance();
            }).start();
        }
    }
}

2. 问题分析：

(1) lazyMan = new LazyMan()，该行代码在极端情况下，是不安全的，因为它不是原子性操作；

(2) 不是原子性操作会经过哪些步骤：

1) 分配内存空间；

2) 执行构造方法，初始化对象；

3) 把这个对象指向这个空间，此时才能保证这个对象被new完了。

(3) 看上去的一步操作，其实是三步操作，此时有可能发生指令重排的现象：

1) 正常情况执行顺序是1 2 3，但是也可以变为 1 3 2，在CUP中是可以做到先分配空间，然后用空对象占用内存，占用之后再去指向对象；

2) 此时如果只有一个A线程来了，步骤1 3 2是不会出现问题的，但是如果当A线程走了步骤1 3，还没有走步骤2的时候，B线程来了，由于A线程已经走到步骤3了，此时B线程就会认定 lazyMan != null，此时就会直接return lazyMan，但是此时还未走步骤2，也就是说 lazyMan 还没有完成构造，就会出现线程安全问题。

3. 解决方法：

添加volatile避免指令重排，代码如下：

public class LazyMan {

    private LazyMan(){
        System.out.println(Thread.currentThread().getName());
    }

    private volatile static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if (lazyMan == null){
            synchronized (LazyMan.class){ // 保证当前类只有一个
                if (lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }

    // 多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10 ; i++) {
            new Thread(() -> {
                LazyMan.getInstance();
            }).start();
        }
    }
}

四. 静态内部类式

1. 代码如下：

public class Holder {

    private Holder(){

    }

    public static Holder getInstance(){
        return InnerClass.holder;
    }

    public static class InnerClass{
        private static final Holder holder = new Holder();
    }
}

这种方式感觉很厉害，花里胡哨的，但是没有多大真实的作用。

五. 反射破解单例

上述4种单例其实都是不安全的，都可以通过反射进行破解，如下通过懒汉式进行破解分析：

1. 代码如下：

public class LazyMan {

    private LazyMan(){
        System.out.println(Thread.currentThread().getName());
    }

    private volatile static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if (lazyMan == null){
            synchronized (LazyMan.class){ // 保证当前类只有一个
                if (lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }

    // 反射破解
    public static void main(String[] args) throws Exception {
        LazyMan instance1 = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance2 = declaredConstructor.newInstance();
        System.out.println("懒汉式创建的lazyMan："+instance1);
        System.out.println("反射创建的lazyMan："+instance2);
    }
}

执行结果：

main
main
懒汉式创建的lazyMan：com.juc.single.LazyMan@14ae5a5
反射创建的lazyMan：com.juc.single.LazyMan@7f31245a

通过结果明显发现不是一个对象。

2. 第一次解决：

public class LazyMan {

    private LazyMan(){
        synchronized (LazyMan.class){
            if (lazyMan != null){
                throw new RuntimeException("禁止反射破坏异常");
            }
        }
        System.out.println(Thread.currentThread().getName());
    }

    private volatile static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if (lazyMan == null){
            synchronized (LazyMan.class){ // 保证当前类只有一个
                if (lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }

    // 反射破解
    public static void main(String[] args) throws Exception {
        LazyMan instance1 = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance2 = declaredConstructor.newInstance();
        System.out.println("懒汉式创建的lazyMan："+instance1);
        System.out.println("反射创建的lazyMan："+instance2);
    }
}

执行结果：

main
Exception in thread "main" java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at com.juc.single.LazyMan.main(LazyMan.java:34)
Caused by: java.lang.RuntimeException: 禁止反射破坏异常
	at com.juc.single.LazyMan.<init>(LazyMan.java:10)
	... 5 more

此时将双重锁检索升级成为三重锁检索避免反射的某一种破坏，但是如果两个对象都是反射创建的情况下，同样可以破解，代码如下：

public class LazyMan {

    private LazyMan(){
        synchronized (LazyMan.class){
            if (lazyMan != null){
                throw new RuntimeException("禁止反射破坏异常");
            }
        }
        System.out.println(Thread.currentThread().getName());
    }

    private volatile static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if (lazyMan == null){
            synchronized (LazyMan.class){ // 保证当前类只有一个
                if (lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }

    // 反射破解
    public static void main(String[] args) throws Exception {
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance1 = declaredConstructor.newInstance();
        LazyMan instance2 = declaredConstructor.newInstance();
        System.out.println("反射创建的lazyMan1："+instance1);
        System.out.println("反射创建的lazyMan2："+instance2);
    }
}

执行结果：

main
main
反射创建的lazyMan1：com.juc.single.LazyMan@14ae5a5
反射创建的lazyMan2：com.juc.single.LazyMan@7f31245a

通过结果明显发现不是一个对象。

3. 第二次解决：

public class LazyMan {

    private static boolean jingZhiFanShe =  false;

    private LazyMan(){
        synchronized (LazyMan.class){
            if (jingZhiFanShe ==  false){
                jingZhiFanShe = true;
            }else{
                throw new RuntimeException("禁止反射破坏异常");
            }
        }
        System.out.println(Thread.currentThread().getName());
    }

    private volatile static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if (lazyMan == null){
            synchronized (LazyMan.class){ // 保证当前类只有一个
                if (lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }

    // 反射破解
    public static void main(String[] args) throws Exception {
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance1 = declaredConstructor.newInstance();
        LazyMan instance2 = declaredConstructor.newInstance();
        System.out.println("反射创建的lazyMan1："+instance1);
        System.out.println("反射创建的lazyMan2："+instance2);
    }
}

执行结果：

main
Exception in thread "main" java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at com.juc.single.LazyMan.main(LazyMan.java:38)
Caused by: java.lang.RuntimeException: 禁止反射破坏异常
	at com.juc.single.LazyMan.<init>(LazyMan.java:14)
	... 5 more

此时通过标志位判断避免反射的某一种破坏，如果不通过反编译，是无法找到该关键字的，如果对关键字做一些加密，就会使创建单例变的更安全，但是再安全的加密也会被解密，代码如下：

public class LazyMan {

    private static boolean jingZhiFanShe =  false;

    private LazyMan(){
        synchronized (LazyMan.class){
            if (jingZhiFanShe ==  false){
                jingZhiFanShe = true;
            }else{
                throw new RuntimeException("禁止反射破坏异常");
            }
        }
        System.out.println(Thread.currentThread().getName());
    }

    private volatile static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if (lazyMan == null){
            synchronized (LazyMan.class){ // 保证当前类只有一个
                if (lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }

    // 反射破解
    public static void main(String[] args) throws Exception {
        Field field = LazyMan.class.getDeclaredField("jingZhiFanShe");
        field.setAccessible(true);

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance1 = declaredConstructor.newInstance();

        field.set(instance1,false);// 将jingZhiFanShe的值改为false

        LazyMan instance2 = declaredConstructor.newInstance();
        System.out.println("反射创建的lazyMan1："+instance1);
        System.out.println("反射创建的lazyMan2："+instance2);
    }
}

通过修改关键字进行破解。

4. 分析newInstance源码：

@CallerSensitive
    public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        // 如果类型是枚举类型，会报错"不能使用反射破坏枚举"
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }

通过源码分析，可以通过枚举方式替换自定义标志位解决。

5. 枚举分析：

(1) 编写枚举类：

public enum EnumSingle {
    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

(2) 直接Idea中分析EmunSingle.class文件：

public enum EnumSingle {
    INSTANCE;

    private EnumSingle() {
    }

    public EnumSingle getInstance() {
        return INSTANCE;
    }
}

从Idea中查看EmunSingle的class文件发现，EmunSingle有一个无参构造器。

(3) 编写测试类：

public enum EnumSingle {
    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println("反射创建的EnumSingle1："+instance1);
        System.out.println("反射创建的EnumSingle2："+instance2);
    }
}

执行结果：

Exception in thread "main" java.lang.NoSuchMethodException: com.juc.single.EnumSingle.<init>()
	at java.lang.Class.getConstructor0(Class.java:3082)
	at java.lang.Class.getDeclaredConstructor(Class.java:2178)
	at com.juc.single.Test.main(EnumSingle.java:16)

此报错说没有该方法，和newInstance源码中的"Cannot reflectively create enum objects"不相符，因为代码的执行结果肯定是不会有问题的，所以说明该class文件是有问题的。

(4) 通过javap分析EmunSingle.class文件：

public final class com.juc.single.EnumSingle extends java.lang.Enum<com.juc.single.EnumSingle> {
  public static final com.juc.single.EnumSingle INSTANCE;
  private static final com.juc.single.EnumSingle[] $VALUES;
  public static com.juc.single.EnumSingle[] values();
  public static com.juc.single.EnumSingle valueOf(java.lang.String);
  private com.juc.single.EnumSingle();
  public com.juc.single.EnumSingle getInstance();
  static {};
}

通过javap -p EnumSingle.class命令查看EmunSingle的class，发现还是一个无参构造器，也是有问题的，那就需要更专业的工具(jad)进行分析。

(5) 通过jad分析EmunSingle.class文件：

public final class EnumSingle extends Enum
{

    public static EnumSingle[] values()
    {
        return (EnumSingle[])$VALUES.clone();
    }

    public static EnumSingle valueOf(String name)
    {
        return (EnumSingle)Enum.valueOf(com/juc/single/EnumSingle, name);
    }

    private EnumSingle(String s, int i)
    {
        super(s, i);
    }

    public EnumSingle getInstance()
    {
        return INSTANCE;
    }

    public static final EnumSingle INSTANCE;
    private static final EnumSingle $VALUES[];

    static 
    {
        INSTANCE = new EnumSingle("INSTANCE", 0);
        $VALUES = (new EnumSingle[] {
            INSTANCE
        });
    }
}

通过jad -sjava EnumSingle.class命令还原EnumSingle.java文件，可以发现EnumSingle是一个有两个参数的构造器。

(6) 重写编写测试类：

public enum EnumSingle {
    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println("反射创建的EnumSingle1："+instance1);
        System.out.println("反射创建的EnumSingle2："+instance2);
    }
}

执行结果：

Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
	at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
	at com.juc.single.Test.main(EnumSingle.java:18)

此时的报错符合我们的预期，证明反射不能破坏枚举的单例。

六. 枚举式

代码如下：

public enum EnumSingleTest {
    INSTANCE;

    public EnumSingleTest getInstance(){
        return INSTANCE;
    }
}

class EnumTest{
    public static void main(String[] args) {
        EnumSingleTest instance = EnumSingleTest.INSTANCE.getInstance();
        System.out.println(instance);
    }
}

推荐使用枚举式单例，利用枚举的特性，让JVM来帮我们保证线程安全和单一实例的问题，并且写法还非常简单；

直接通过EnumSingleTest.INSTANCE.getInstance()的方式调用即可。

PS：该文档为【狂神说Java】JUC并发编程最新版通俗易懂_哔哩哔哩_bilibili 中单例模式的学习笔记，推荐想快速理解例模式的去B站学习。

BestandW1shEs
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java SE程序 单例模式
01-21
Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式...
单列模式
明耀的博客
06-12 122
+ (instancetype)newInstance:(CGRect)frame{ static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ if(mWeeksChooseView == nil){ mWeeksChooseView = [[MSWeeksChoos...
什么是单例模式？
热门推荐
qq_36403434的博客
01-24 3万+
单例模式第一版： public class Singleton { private Singleton() {} //私有构造函数 private static Singleton instance = null; //单例对象 //静态工厂方法 public static Singleton getInstance() { if (insta
C#设计模式–单例模式
12-22
首先我介绍的是设计模式中比较简单的一个模式——单例模式（因为这里只牵涉到一个类） 　二、单例模式的介绍 　说到单例模式，大家第一反应应该是——什么是单例模式？，从“单例”字面意思上理解为——一个类只有...
基于JavaScript实现单例模式
01-19
首先，了解一下什么是单例模式，这里我直接把软件开发网中的定义给copy过来： 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。...
.Net 单例模式(Singleton)
01-02
 单例模式 Singleton Pattern 问题解决： （1）单例模式简介： Singleton模式要求一个类有且仅有一个实例，并且提供了一个全局的访问点。这就提出了一个问题：如何绕过常规的构造器，提供一种机制来保证一个类只有...
设计模式—— 七 ：单例模式
01-21
单例模式的实现饿汉式懒汉式线程安全的懒汉式登记式单例模式的优缺点单例模式的优点单例模式的缺点 单例模式是23个模式中比较简单的模式，应用也非常广泛 什么是单例模式？ 单例模式的定义： Ensure a class ...
反射会打破单例模式吗
qq_51967234的博客
04-25 640
为了避免这种情况，一种可能的解决方案是使单例类的构造器抛出异常（如果检测到已经有一个实例存在），或者在创建实例时检查是否已经有实例存在。因此，在设计单例模式时，需要考虑到反射可能带来的风险，并考虑使用其他机制（如枚举单例）来增强单例的安全性。单例模式确保一个类只有一个实例，并提供一个全局访问点。然而，通过Java反射API，我们可以绕过私有构造器和静态变量，从而可能创建类的多个实例，进而破坏单例模式的约束。，这表明通过反射我们成功地绕过了单例模式的限制，并创建了多个实例。类的实例，并验证它们是否相同。
Django-admin单例模式和懒加载
最新发布
m0_72839702的博客
04-29 713
当我们实例化对象时，就会在内存开一个空间__new____init__name="张三"__new____init__单例模式的目的，就是让我们在创建类对象时，都使用第一次创建的类对象，而不是像上文那样每次使用时都创建一个对象python的执行顺序是1加载admin.py文件2实例化一个对象3当我们再次导入admin.py文件时，python不会重新加载，步骤4也就是一开始创建的admin对象，并不会重新创建一个新的对象。
设计模式（四）：单例模式
wenqi1992的博客
04-23 767
单例模式的介绍
Java设计模式 _创建型模式_单例模式(懒汉式，饿汉式)
weisian的博客
04-26 554
一个类负责创建自己的对象，同时确保只有1个对象被创建，这个类提供了一种访问其唯一的对象的方式，不需要在实例化该类的对象。存在问题：会在类装载的时候就占用一定的内存空间，如果该类的方法没有用到，就造成一定的内存浪费。（3）、提供public的方法获取实例对象（如果有实例直接返回，没有实例，创建实例后在返回）特点：先不创建该类的实例，在获取实例的方法中，根据判断，如果不存在才生成和返回。特点：在加载这个类的时候就创建了这个类的实例，在获取的方法中直接返回。（1）、该类中定义该类的实例属性，私有化。
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 798
都是符合我们的预期的。
单例模式
05-24
单例模式是一种软件设计模式，它保证一个类只有一个实例，并提供一个全局访问点让其他对象可以访问这个唯一的实例。单例模式在需要控制一个类的实例数量时非常有用，例如数据库连接池、线程池等。 实现单例模式有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值