单例模式介绍

已于 2023-08-19 16:08:52 修改
阅读量7.5k 收藏 17
点赞数 5
分类专栏： 设计模式 文章标签： java
于 2022-04-05 15:57:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50652600/article/details/123968328
版权

原文链接：单例模式介绍 – 编程屋

目录

1 前言

2 单例模式类型

2.1 饿汉式：

2.2 懒汉式：

2.2.1 双重检查锁

2.2.2 volatile防止指令重排

2.3 静态内部类

3 破坏单例

1 前言

单例模式是指在内存中有且只会创建一次对象的设计模式，在程序中多次使用同一个对象且作用相同的时候，为了防止频繁的创建对象，单例模式可以让程序在内存中创建一个对象，让所有的调用者都共享这一单例对象。单例模式的类型有两种：懒汉式和饿汉式。

2 单例模式类型

  • 饿汉式：在类加载的时候已经创建好该单例对象。
  • 懒汉式：在需要使用对象的时候才会去创建对象

2.1 饿汉式：

//饿汉式
public class Hungry {

    /**
     * 构造器私有 拒绝别人创建这个对象
     */
    private Hungry() {
    }

    private final static Hungry HUNGRY = new Hungry();

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

大家都知道饿汉式单例是程序启动的时候就已经创建好了对象，那么这样的会会有什么问题呢？有可能浪费空间

为什么呢？因为如果在该类中声明了许多内存空间，但却没有使用的话，就很浪费内存空间，因为饿汉式它是在程序启动的时候就已经创建好了。如下：

//饿汉式
public class Hungry {

    //可能会浪费空间
    private byte[] data1 = new byte[1024 * 1024];
    private byte[] data2 = new byte[1024 * 1024];
    private byte[] data3 = new byte[1024 * 1024];
    private byte[] data4 = new byte[1024 * 1024];
    private byte[] data5 = new byte[1024 * 1024];
    
    /**
     * 构造器私有 拒绝别人创建这个对象
     */
    private Hungry() {
    }

    private final static Hungry HUNGRY = new Hungry();

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

那么既然饿汉式单例有问题，那么就出现了懒汉式单例模式，需要对象的时候才会去创建。

2.2 懒汉式：

//懒汉式单例
public class LazySingle {

    private LazySingle(){

    }
    private static LazySingle lazySingle;

    public static LazySingle getInstance(){
        if (lazySingle == null ) {
            lazySingle = new LazySingle();
        }
        return lazySingle;
    }
}

2.2.1 双重检查锁

但是这样会不会有问题呢？这样创建的懒汉式单例模式在单线程环境下肯定是没问题的，但是在多线程环境下，就会有问题了。就会不止创建一个对象了，那么如何改进呢？如下：

//懒汉式单例
public class LazySingle {

    private LazySingle(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private static LazySingle lazySingle;

    //双重检查加锁
    public static LazySingle getInstance(){
        if (lazySingle == null ){
            synchronized (LazySingle.class){
                if (lazySingle == null ) {
                    lazySingle = new LazySingle();
                }
            }
        }
        return lazySingle;
    }

这就是双重检查加锁的机制了（DCL懒汉式），这样就可以保证在多线程环境下有且仅会创建一个对象。

2.2.2 volatile防止指令重排

那么这样的双重检查锁是完整的吗，会不会出现一些其他的问题呢？其实也是会的，因为当我们在 new LazySingle()的时候，其实是有可能发生指令重排的。

  • 1 分配内存空间
  • 2 执行构造方法，初始化对象
  • 3 把这个对象指向这个空间

正常情况下，执行的这个顺序是1,2,3，如果在发生了指令重排，并且在多线程的环境下，也会出现问题。比如：A线程指令重排1,3,2，那么在重排过程中线程B进来，发现lazySingle已经分配内存空间了，不等于null了，那么就直接返回了，对于这种情况应该怎样处理呢？可以使用volatile关键字来解决，如下：

//懒汉式单例
public class LazySingle {

    private LazySingle(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private volatile static LazySingle lazySingle;

    //双重检查加锁
    public static LazySingle getInstance(){
        if (lazySingle == null ){
            synchronized (LazySingle.class){
                if (lazySingle == null ) {
                    lazySingle = new LazySingle();
                }
            }
        }
        return lazySingle;
    }


}

2.3 静态内部类

除此之外，我们还可以使用静态内部类来实现：

//静态内部类
public class Holder {

    private Holder(){

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

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

3 破坏单例

但是无论是懒汉式单例还是饿汉式单例，都可以利用反射去破坏

    public static void main(String[] args) throws Exception {
        //通过正常方式获得对象
        LazySingle instance = LazySingle.getInstance();
        Constructor<LazySingle> declaredConstructor = LazySingle.class.getDeclaredConstructor(null);
        //可访问私有构造器
        declaredConstructor.setAccessible(true);
        //利用反射构造新对象
        LazySingle lazySingle = declaredConstructor.newInstance();
        System.out.println(instance.equals(lazySingle)); //false
    }

以上就是利用反射强制访问类的私有构造器，去创建另外一个对象

那么如何去解决它呢？

//懒汉式单例
public class LazySingle {

    private LazySingle(){
        synchronized (LazySingle.class){
            if (lazySingle != null ) {
                throw new RuntimeException("不要利用反射去破坏单例");
            }
        }
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private volatile static LazySingle lazySingle;

    //双重检查加锁
    public static LazySingle getInstance(){
        if (lazySingle == null ){
            synchronized (LazySingle.class){
                if (lazySingle == null ) {
                    lazySingle = new LazySingle();
                }
            }
        }
        return lazySingle;
    }


    public static void main(String[] args) throws Exception {
        //通过正常方式获得对象
        LazySingle instance = LazySingle.getInstance();
        Constructor<LazySingle> declaredConstructor = LazySingle.class.getDeclaredConstructor(null);
        //可访问私有构造器
        declaredConstructor.setAccessible(true);
        //利用反射构造新对象
        LazySingle lazySingle = declaredConstructor.newInstance();
        System.out.println(instance.equals(lazySingle));
    }
}

控制台输出：

 以上是通过正常调用了对象和通过反射调用了一次对象发现单例被破坏了，那么如果两次直接在反射中去创建对象，这样会被发现吗？

    public static void main(String[] args) throws Exception {
        //通过正常方式获得对象
//        LazySingle instance = LazySingle.getInstance();
        Constructor<LazySingle> declaredConstructor = LazySingle.class.getDeclaredConstructor(null);
        //可访问私有构造器
        declaredConstructor.setAccessible(true);
        //利用反射构造新对象
        LazySingle lazySingle = declaredConstructor.newInstance();
        LazySingle lazySingle1 = declaredConstructor.newInstance();
        System.out.println(lazySingle1.equals(lazySingle)); //false
    }
}

这样可见，直接这样去操作的话，单例被破坏依然是发现不了的，那么如何去解决呢？我们可以在私有构造器中加上一个标识，根据标识去判断，如下：

//懒汉式单例
public class LazySingle {

    private static Boolean flag = false;

    private LazySingle(){
        synchronized (LazySingle.class){
            if (!flag) {
                flag = true;
            }else {
                throw new RuntimeException("不要利用反射去破坏单例");
            }
        }
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private volatile static LazySingle lazySingle;

    //双重检查加锁
    public static LazySingle getInstance(){
        if (lazySingle == null ){
            synchronized (LazySingle.class){
                if (lazySingle == null ) {
                    lazySingle = new LazySingle();
                }
            }
        }
        return lazySingle;
    }


    public static void main(String[] args) throws Exception {
        //通过正常方式获得对象
//        LazySingle instance = LazySingle.getInstance();
        Constructor<LazySingle> declaredConstructor = LazySingle.class.getDeclaredConstructor(null);
        //可访问私有构造器
        declaredConstructor.setAccessible(true);
        //利用反射构造新对象
        LazySingle lazySingle = declaredConstructor.newInstance();
        LazySingle lazySingle1 = declaredConstructor.newInstance();
        System.out.println(lazySingle1.equals(lazySingle)); //false
    }
}

控制台输出：

这样就万无一失了吗？就能保证它不被破坏了吗，俗话说魔高一尺，道高一丈，反射依然可以去破坏它

    public static void main(String[] args) throws Exception {
        //通过正常方式获得对象
//        LazySingle instance = LazySingle.getInstance();
        Field flag = LazySingle.class.getDeclaredField("flag");
        flag.setAccessible(true);
        Constructor<LazySingle> declaredConstructor = LazySingle.class.getDeclaredConstructor(null);
        //可访问私有构造器
        declaredConstructor.setAccessible(true);
        //利用反射构造新对象
        LazySingle lazySingle = declaredConstructor.newInstance();
        flag.set(lazySingle,false);
        LazySingle lazySingle1 = declaredConstructor.newInstance();
        System.out.println(lazySingle1.equals(lazySingle)); //false
    }

 可见啊，无论我们如何去防止它，这个反射总是可以去破解我们的单例。那究竟怎样才能解决这个问题呢？那么就得看下反射到底是如何去创建一个对象的了。

发现显示不能用反射去破坏枚举，那么真的可以这样吗，我们来试一下：

枚举类：

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(instance1);
        System.out.println(instance2);
    }
}

测试结果：

可见真的不能用反射区破坏枚举。

注意：此时枚举类中不是无参构造，而是有参构造

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

以上只是部分内容，为了维护方便，本文已迁移到新地址：单例模式介绍 – 编程屋

想养一只萨摩耶～
关注
  • 5
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C++中的单例模式介绍
01-21
单例模式有许多种实现方法，在C++中，甚至可以直接用一个全局变量做到这一点，但这样的代码显的很不优雅。 使用全局对象能够保证方便地访问实例，但是不能保证只声明一个对象——也就是说除了一个全局实例外，仍然...
单例模式简介
wuyuanman的博客
10-20 369
单例模式是面试中问的最多的设计模式之一，同时它也是最基础的设计模式。说它基础，并不意味着简单，涉及到的延伸知识点非常多。如果要深究下去，可以把Java的基础知识问个遍。本文不作特别细致的讲解，抛砖引玉提几点比较重要的地方，以记录第一次在工作中的使用。 1、什么是单例模式？ 保证一个类仅有一个实例，并提供一个访问它的全局访问点。 2、为什么要用单例模式？ 对啊，为什么要使用？其实我刚开始的时...
一文带你彻底搞懂设计模式之单例模式！！由浅入深，图文并茂，超超超详细的单例模式讲解！！
最新发布
祝你身体健康，美满幸福
06-28 2929
本篇文章通过图文形式，由浅入深，详细讲解了设计模式中的单例模式的应用
PHP最常用的2种设计模式工厂模式和单例模式介绍
10-27
本篇文章将介绍PHP中最为常用的两种设计模式——工厂模式和单例模式。 首先，工厂模式的主要作用是降低系统各模块之间的耦合度。耦合度是指模块之间的依赖关系，耦合度越低，系统的模块越独立，越容易升级和维护。...
Java单例模式简单介绍
08-29
"Java单例模式简单介绍" 单例模式是一种常用的软件设计模式，它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并...
什么是单例模式？
weixin_30553065的博客
03-18 863
单例模式： 1.保证类在内存中只能有一个对象单例模式分为： 1.懒汉式：类一加载就创建对象 2.饿汉式：用的时候，才去创建对象相关经验： 饿汉式 （是不会出现问题的单例模式） 懒汉式 （可能会出现问题的单例模式） （1.）懒加载（延迟加载） （2.）线程安全问题 1.）是否多线程环境 是 2.）是否有共享数...
关于C++中Singleton类实例析构的讨论[zz]
varding的专栏
12-22 1109
<br /><br />http://hi.baidu.com/funrole/blog/item/880f250f636d7ae1aa645727.html<br /> <br /> 单例模式也称为单件模式、单子模式，可能是使用最广泛的设计模式。其意图是保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。有很多地方需要这样的功能模块，如系统的日志输出，GUI应用必须是单鼠标，MODEM的联接需要一条且只需要一条电话线，操作系统只能有一个窗口管理器，一台PC连一个键盘。<br /
常见的几种单例模式
weixin_30823683的博客
02-23 168
转载自：https://www.cnblogs.com/Ycheng/p/7169381.html 单例模式：是一种常用的软件设计模式，在它的核心结构中值包含一个被称为单例的特殊类。一个类只有一个实例，即一个类只有一个对象实例。 　　对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；售票时，一共有100张票，可有有多个窗口同时售票，...
简述-单例模式
ddxxii的博客
05-27 389
单例方式看到很多人写单例都不考虑线程安全，当多线程操作当时候，就可能出现多个实例，那么不就违背了单例的初衷了么？如果要维护到单例类中到成员，那就更尴尬了，我看到也实在是无奈，所以这里建议大家写单例是需要做到线程安全到！！首先说推荐单例模式写法,其目的主要是为了做到线程安全： DCL (Double CheckLock) public class Singleton { private Sin
单例模式简单介绍
qq_36658567的博客
07-30 198
1.什么是单例模式 2.怎么使用单例模式 3.什么场景下使用 4.单例模式Android中的应用 5.常见问题
Day40-设计模式-单例模式
欢迎来到Liu_zimo的博客
03-04 183
title: Day40-设计模式-单例模式 date: 2021-03-03 18:11:46 author:Liu_zimo 设计模式 设计模式分为三种类型，共23种 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。 行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式(Interpreter模式)、状态模式、策略模式、职责链模式(责任链.
介绍一下C++ 单例模式
06-13
C++ 单例模式是一种常用的设计模式，它的主要目的是确保一个类只有一个实例，并提供全局访问该实例的方法。它通常被用来管理全局资源，例如日志记录器、配置文件、数据库连接等。 实现单例模式的关键在于确保类只有一个实例，并提供全局访问该实例的方法。在 C++ 中，可以通过静态成员变量和静态成员函数来实现这一点。 例如，下面是一个简单的 C++ 单例模式的实现： ```cpp class Singleton { private: static Singleton* instance; // 静态成员变量，用于保存单例实例 Singleton() {} // 构造函数私有化，保证外部无法直接创建实例 public: static Singleton* getInstance() { // 静态成员函数，用于获取单例实例 if (instance == nullptr) { instance = new Singleton(); // 如果实例不存在，就创建一个新的实例 } return instance; // 返回单例实例 } }; Singleton* Singleton::instance = nullptr; // 初始化静态成员变量 ``` 在上面的例子中，我们将构造函数私有化，这样就可以防止外部直接创建实例。同时，我们使用静态成员变量 `instance` 来保存单例实例，并使用静态成员函数 `getInstance` 来获取单例实例。在 `getInstance` 函数中，我们首先检查实例是否已经存在，如果不存在就创建一个新的实例。最后，我们返回单例实例。 使用单例模式时需要注意线程安全问题，可以使用线程安全的实现方式来避免多线程问题。此外，单例模式也有一些缺点，例如可能会导致代码耦合性增加、难以进行单元测试等。因此，在使用单例模式时需要谨慎考虑。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值