单例模式设计模式（详细，易懂）

于 2024-03-21 11:16:34 发布
阅读量750 收藏 6
点赞数 25
分类专栏： 设计模式 文章标签： 单例模式 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47100953/article/details/136903138
版权

单例模式

单例模式一定安全吗？哪些方式可以破坏单例模式？

单例模式不一定安全，以下几种方式可以破坏单例模式：

  1. 多线程环境下的线程安全性：
  • 如果多个线程同时访问单例对象的获取方法，可能会导致多次创建实例或出现竞态条件，从而破坏单例模式。
  • 解决方法：可以通过加锁（如使用synchronized关键字或ReentrantLock）来确保在多线程环境下只有一个线程可以创建实例，来保证单例。
  1. 序列化和反序列化：
  • 当单例类实现了Serializable接口时，单例对象可以被序列化和反序列化。在反序列化时，会创建一个新的对象，从而破坏了单例模式。
  • 解决方法：可以通过重写readResolve()方法，在反序列化时返回单例对象，确保反序列化后仍然是同一个单例对象。
  1. 反射：
  • 通过反射机制可以调用类的私有构造方法来创建对象，从文破坏单例模式。
  • 解决方法：可以在构造方法中添加逻辑，防止多次实例化；或这在创建第二个实例时抛出异常。
  1. 类加载器：
  • 在一些特殊情况下，可能会存在多个类加载器加载同一个类，导致创建多个单例对象的情况。
  • 解决方法：可以通过控制类加载器的方式来确保只有一个类加载器加载单例类。
  1. 多个实例：
  • 单例模式的实现可能并不完全符合单例模式的定义，例如通过静态变量或静态方法来实现单例，但在多个类加载器的情况下可能会创建多个单例对象。
  • 解决方法：确保单例模式的实现符合单例模式的定义，同时考虑类加载器的影响。
  1. 拷贝可以破坏单例
定义

确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

饿汉式

饿汉式单例模式就是在类加载的时候就立即初始化，并且创建单例对象。
不管你有没有用到，都先建好了再说。它绝对线程安全，在线程还没出现以前就实例化了，不可能存在访问安全问题。

优点

线程安全，没有加任何锁、执行效率比较高。

缺点

类加载的时候就初始化，不管后期用不用都占着空间，浪费内存，不推荐这样使用单例。

代码示例
/**
 * 单例模式
 * 饿汉式：类加载时就立即初始化，并且创建单例对象。
 * 线程安全，占用资源
 */
public class HungrySingleton {
    //先静态，后动态；先属性，后方法；先上后下；
    private static final HungrySingleton hungrySingleton = new HungrySingleton();

    //构造函数私有
    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }
}

/**
 * 单例模式
 * 饿汉式(静态代码块实现)：类加载时就立即初始化，并且创建单例对象。
 * 线程安全，占用资源
 */
public class HungryStaticSingleton {
    //先静态，后动态；先属性，后方法；先上后下；
    private static final HungryStaticSingleton hungrySingleton;

    static {
        hungrySingleton = new HungryStaticSingleton();
    }

    //构造函数私有
    private HungryStaticSingleton() {
    }

    public static HungryStaticSingleton getInstance() {
        return hungrySingleton;
    }
}
懒汉式

实例在用到的时候才去检查有没有实例，如果有则直接返回，没有则新建

/**
 * 单例模式
 * 懒汉式：实例在用到时才去检查有没有实例，没有则创建，有则返回。
 */
public class LazySimpleSingleton {
    private static LazySimpleSingleton lazySimpleSingleton = null;

    //构造函数私有
    private LazySimpleSingleton() {
    }

    public static LazySimpleSingleton getInstance() {
        if (lazySimpleSingleton == null) {
            lazySimpleSingleton = new LazySimpleSingleton();
        }
        return lazySimpleSingleton;
    }
}

上面这种写法不是线程安全的：
在多线程情况下，如果两个线程同时走到if (lazySimpleSingleton == null)这个判断，因为lazy还没有实例化过，所以两个线程判断的结果都是true，然后同时进入代码块创建了多个实例，返回不是同一个对象，线程不安全。

/**
 * 单例模式
 * 懒汉式：实例在用到时才去检查有没有实例，没有则创建，有则返回。
 */
public class LazySimpleSingleton {
    private static LazySimpleSingleton lazySimpleSingleton = null;

    //构造函数私有
    private LazySimpleSingleton() {
    }

    public synchronized static LazySimpleSingleton getInstance() {
        if (lazySimpleSingleton == null) {
            lazySimpleSingleton = new LazySimpleSingleton();
        }
        return lazySimpleSingleton;
    }
}

可以加锁synchronized修饰解决线程安全问题，但是在线程数量比较多的情况下，大量线程会阻塞在方法外部，导致程序性能下降。所以为了兼顾性能和线程安全问题，可以使用双重检查锁方式来创建懒汉式单例：

/**
 * 单例模式
 * 懒汉式：实例在用到时才去检查有没有实例，没有则创建，有则返回。
 */
public class LazySimpleSingleton {
    private static LazySimpleSingleton lazySimpleSingleton = null;

    //构造函数私有
    private LazySimpleSingleton() {
    }

    public static LazySimpleSingleton getInstance() {
        if (lazySimpleSingleton == null) {
            synchronized (LazySimpleSingleton.class) {
                lazySimpleSingleton = new LazySimpleSingleton();
            }
        }
        return lazySimpleSingleton;
    }
}

使用synchronized关键字总归要上锁，对程序性能还是存在一定影响。

/**
 * 静态内部类方式
 * 兼顾饿汉式单例模式的内存浪费问题和synchronized的性能问题
 */
public class LazyInnerClassSingleton {

    //使用LazyInnerClassSingleton的时候，默认会先初始化内部类
    //如果没有使用，则内部类是不加载的。
    private LazyInnerClassSingleton() {
    }

    //static是为了使单例的空间共享，保证这个方法不会被重写、重载
    public static final LazyInnerClassSingleton getInstance() {
        //在返回结果以前，一定会先加载内部类。
        return LazyHolder.LAZY;
    }

    //默认不加载
    private static class LazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

这种方式兼顾了饿汉式单例的内存浪费问题和synchronized的性能问题。内部类一定是要在方法调用之前初始化，巧妙地避免了线程安全问题。

反射破坏单例

饿汉式和懒汉式单例都是将构造函数私有，用来防止通过new来创建对象实例。

public class LazyInnerClassSingletonTest {

    public static void main(String[] args) throws Exception {
        Class<LazyInnerClassSingleton> clazz = LazyInnerClassSingleton.class;
        //通过反射获取私有的构造函数
        Constructor<LazyInnerClassSingleton> c = clazz.getDeclaredConstructor(null);
        //强制访问
        c.setAccessible(true);
        //暴力初始化
        LazyInnerClassSingleton singleton = c.newInstance();
        //调用两次构造方法，相当于new了两次，违反单例原则。
        LazyInnerClassSingleton instance = singleton.getInstance();
        System.out.println(singleton == instance);//false
    }
}

/**
 * 静态内部类方式
 * 兼顾饿汉式单例模式的内存浪费问题和synchronized的性能问题
 */
public class LazyInnerClassSingleton {

    //使用LazyInnerClassSingleton的时候，默认会先初始化内部类
    //如果没有使用，则内部类是不加载的。
    private LazyInnerClassSingleton() {
        //防止反射破坏单例
        if (LazyHolder.LAZY != null) {
            throw new RuntimeException("不允许创建多个实例");
        }
    }

    //static是为了使单例的空间共享，保证这个方法不会被重写、重载
    public static final LazyInnerClassSingleton getInstance() {
        //在返回结果以前，一定会先加载内部类。
        return LazyHolder.LAZY;
    }

    //默认不加载
    private static class LazyHolder {
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}
序列化破坏单例

一个单例对象创建好后，有时候需要将对象序列化然后写入磁盘，下次使用时再从磁盘中读取对象并进行反序列化，会重新分配内存，也就是重新创建对象。就会破坏单例。

/**
 * 反序列化破坏单例
 */
public class SeriableSingleton implements Serializable {
    //序列化就是把内存中的状态通过转换成字节码的形式
    //从而转换一个I/O流，写入磁盘或网络I/O
    //内存中的状态会永久保存下来

    //反序列化就是将已经持久化的字节码内容转化为I/O流
    //通过I/O流的读取，进而将读物的内容转换为Java对象
    //在转换过程中会重新创建对象new
    private static final SeriableSingleton INSTANCE = new SeriableSingleton();

    private SeriableSingleton() {
    }

    public static SeriableSingleton getInstance() {
        return INSTANCE;
    }
}

public class SeriableSingletonTest {
    public static void main(String[] args) {
        SeriableSingleton instance = SeriableSingleton.getInstance();
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        try {
            //序列化
            FileOutputStream fos = new FileOutputStream("SeriableSingleton.obj");
            oos = new ObjectOutputStream(fos);
            oos.writeObject(instance);
            //反序列化
            FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
            ois = new ObjectInputStream(fis);
            SeriableSingleton instance2 = (SeriableSingleton) ois.readObject();
            System.out.println(instance2 == instance);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
                if (oos != null) {
                    oos.close();
                }
            } catch (Exception e) {

            }
        }
    }
}

结果为false，可知反序列化的对象和原始对象不是同一个，打破了单例。
解决方案：只需增加readResolve()方法即可。

public class SeriableSingleton implements Serializable {

    //序列化就是把内存中的状态通过转换成字节码的形式
    //从而转换一个I/O流，写入磁盘或网络I/O
    //内存中的状态会永久保存下来

    //发序列化就是将已经持久化的字节码内容转化为I/O流
    //通过I/O流的读取，进而将读物的内容转换为Java对象
    //在转换过程中会重新创建对象new

    private static final SeriableSingleton INSTANCE = new SeriableSingleton();

    private SeriableSingleton() {
    }

    public static SeriableSingleton getInstance() {
        return INSTANCE;
    }

    //解决反射导致破坏单例的问题
    private Object readResolve(){
        return INSTANCE;
    }
}

通过源码可知底层是通过反射来找到一个无参的readResolve()方法，并返回该方法返回值。
虽然增加readResolve()方法返回实例解决了单例模式被破坏的问题，但是实际上实例化了两次，只不过新创建的对象没有被返回而已。

注册式单例模式

注册式单例模式又叫登记式单例模式，就是将每一个实例都登记到某一个地方，使用唯一的标识获取实例。
注册式单例模式有两种：一种为枚举式单例模式，另一种为容器式单例模式。

枚举式单例模式
public enum EnumSingleton {
    INSTANCE;

    private Object data;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
}

序列化和反序列化不会破坏枚举式单例。
通过反射也不能破坏枚举式单例，会报错找不到无参构造器，无法使用反射创建枚举。

容器式单例
/**
 * 容器式单例
 */
public class ContainerSingleton {
    private ContainerSingleton() {
    }

    private static Map<String, Object> ioc = new ConcurrentHashMap<String, Object>();

    public static Object getBean(String className) {
        synchronized (ioc) {
            if (ioc.containsKey(className)) {
                return ioc.get(className);
            } else {
                Object obj = null;
                try {
                    //通过类加载器来创建对象
                    obj = Class.forName(className);
                    ioc.put(className, obj);
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
                return obj;
            }
        }
    }
}

容器式单例模式适用于实例非常多的情况，便于管理。但是它是非线程安全的。

学 无止境
关注
专栏目录
单例设计模式源码和案例解析
01-30
本篇将深入解析单例设计模式的四种实现方式，并通过具体的案例进行详细分析。 一、懒汉式（线程不安全） 懒汉式单例的特点是在类被加载时并不创建实例，而是首次调用getInstance()方法时才创建。这种实现方式简单...
js单例模式的两种方案
10-26
在JavaScript中，单例模式是一种常用的软件设计模式，其主要目的是确保一个类只有一个实例，并提供一个全局访问点。这种模式广泛应用于需要频繁创建的对象，例如日志记录器、数据库连接等场景，通过单例模式可以有效...
单例模式(线程安全)
pawlaibd的博客
03-25 639
单例模式 (饿汉模式,懒汉模式)
详解单例模式线程安全
闰土的博客
07-18 1079
各形式线程安全的单例模式
Spring框架中的单例bean是线程安全的吗?
smilehappiness的博客
08-15 7738
结论： 不是线程安全的 Spring容器中的Bean是否线程安全，容器本身并没有提供Bean的线程安全策略，因此可以说Spring容器中的Bean本身不具备线程安全的特性，但是具体还是要结合具体scope的Bean去研究。 Spring 的 bean 作用域（scope）类型 　　1、singleton:单例，默认作用域。 　　2、prototype:原型，每次创建一个新对象。 　　3、request:请求，每次Http请求创建一个新对象，适用于WebApplicationContext环境下。
⛳ 面试题-单例模式会存在线程安全问题吗？
松柏123的博客
08-31 1573
单例模式是 Java 中常用的设计模式之一，属于设计模式三大类中的创建型模式。在运行期间，保证某个类仅有一个实例，并提供一个访问它的全局访问点。单例模式所属类的构造方法是私有的，所以单例类是不能被继承的。实现线程安全的单例模式有以下几种方式有：饿汉式、懒汉式、懒汉式改良版（双重同步锁），内部静态类、枚举；相比于饿汉式，懒汉式显得没那么 “饿”，在真正需要的时候在去创建实例。优点：线程安全的，可以延时加载。缺点：调用效率不高（有锁，且需要先创建对象）、使用反射，序列化创建对象依然可以不是单例的。
五种单例模式的安全性问题
hank之路
02-26 2210
在之前两讲中，介绍了懒汉式、饿汉式、双重锁、内部类、枚举5种单例模式，其实单例模式还有很多种设计，在此就不一一介绍了。 在这5种单例模式中，枚举最为特殊，由于是官方提供的一种模式，所以不能被破解，是十分安全的。 在剩余4种中，我们以懒汉式为例说说安全问题。
单例模式 分析代码优化方法
09-03
饿汉式单例模式的优点是简单易懂，缺点是初始化时就会创建单例对象，即使它不被使用也会占用内存空间。代码如下： ```java public class Single { private static Single single = new Single(); private Single()...
设计模式——单例模式（懒汉模式）
08-10
本文将详细探讨单例模式的懒汉式实现，并结合源码进行解析。 首先，我们要理解单例模式的基本原则：限制类的实例化次数，确保一个类只有一个实例，并提供一个全局访问点。懒汉式单例模式的特点是延迟加载，即只有在...
java设计模式-单例.pdf
最新发布
05-16
### Java设计模式——单例模式详解 #### 一、单例模式概述 单例模式是设计模式中的一个重要组成部分，属于创建型模式之一。其主要作用是确保某个类仅有一个实例存在，并提供一个全局访问该实例的方法。这在很多场景...
你的单例模式真的足够安全吗？
Joshua_Pang的博客
03-17 326
曾经有老师们教过一种方法能够很好的去避免多线程申请单例模式创建一个实例对象的时候创建出多个不同的对象。而包括阿里巴巴的代码业务处理方式推荐清单也明码标价是这样。但是辩证法却无处不在，正所谓魔高一尺道高一丈，总有一些杠精喜欢钻牛角尖，打官司里叫做钻法律空子，互联网里叫做黑客。从比较深层的机制来讲，我们往往可以通过反射机制的一系列“反人类”操作实现对代码安全度的破坏！ 相信大家的老师们曾经都是这样教学的，对吧？ 没错这样子确实能够规避错误某一方面不需要领略synchronized那种烂番茄低下的效率，一
单例模式的安全性
一罐热茶
10-02 655
单例模式，我想大家再熟悉不过了，不过本文不是介绍单例模式该怎么写的。来了解单例怎么写的，请 移步。 本文来说说怎么破坏一个单例，让你写的单例变成一个假的单例。当然，本文也会给出怎么进行防守的方法。 一个简单的单例 来一个简单的单例模式例子： public class Singleton { private static final Singleton INSTANCE = new...
单例模式中存在的安全问题
洛北辰南的博客
11-04 735
线程安全问题 双重校验锁 public class Singleton { private static Singleton instance = null; // 私有构造函数 private Singleton() {} public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) {
Java 单例模式的安全实现方式
好久不见
08-12 2217
Java 单例模式的安全实现方式
单例模式是否线程安全
zzzzzz55300411的博客
05-06 1841
今天领导问了个问题说单例模式中，对象的变量是否是线程安全的。起初都不太确定，后来本着装的目的，试了一下，结果是否定的。在多线程环境下，对象的成员变量是不安全的。 [code="java"] package com.zhuyang.test; public class Singleton { private static final Singleton singleton; //...
java 线程安全的单例_单例模式怎么保证线程安全?java写一个线程安全的单例模式...
weixin_31677427的博客
02-20 337
java单例模式如何才能保证线程安全呢?下面要给大家分享的就是线程安全的单例模式代码，一起来详细的了解一下。1.饿汉式单例，指的就是在方法调用之前，实例就已经创建完成了。packagejichu;publicclassSingleton{privatestaticSingletoninstance=newSingleton();privateSingleton(){}publi...
静态内部类实现的单例模式是如何保证线程安全的
yao_94的博客
09-18 6752
静态内部类实现的单例模式如下： public class Singleton {     private Singleton(){              }          public static Singleton getInstance(){         return SingletonHolder.sInstance;     }          private stati...
单例模式在多线程中的安全性研究
weixin_30387799的博客
04-06 190
概述 关于一般单例模式的创建和分析在我的另一篇博客《Java设计模式——单件模式》中有详细说明。只是在上篇博客中的单例是针对于单线程的操作，而对于多线程却并不适用，本文就从单例模式与多线程安全的角度出发，讲解单例模式在多线程中应该如何被使用。 版权说明 著作权归作者所有。 商业转载请联系作者获得授权，非商业转载请注明出处。 本文作者：Coding-Naga ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值