深究单例模式

已于 2022-09-02 17:25:11 修改
阅读量95 收藏
点赞数
文章标签： 单例模式 java 开发语言
于 2022-09-02 15:07:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsmbnyzwn/article/details/126662188
版权

饿汉式、DCL懒汉式、深究！

饿汉式：

//饿汉式单例
//可能会浪费空间
public class Hungry {
    
    private Hungry(){
        
    }
    
    private final static Hungry HUNGRY = new Hungry();
    
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

懒汉式：

//懒汉式单例
public class LazyMan {

    private LazyMan(){

    }

    private static LazyMan lazyMan;

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

注意：懒汉式单例在单线程模式下，单例模式是没有问题的。但是在多线程并发的情况下，单例模式偶尔成功，偶尔失败。为了解决这个问题，需要加锁处理。如下代码所示：

//懒汉式单例
public class LazyMan {

    private LazyMan(){

    }

    private static LazyMan lazyMan;

    //双重检测锁模式的懒汉式单例。 简称DCL懒汉式
    //主要目的是解决多线程并发单例失败问题。
    public static LazyMan getInstance(){
        if(lazyMan == null){
            synchronized (LazyMan.class){
                if(lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }
}

 注意：这个时候还不是完美的，有两个原因，不是原子性操作，，导致的指令重排现象，分析如下：

//懒汉式单例
public class LazyMan {

    private LazyMan(){

    }

    private static LazyMan lazyMan;

    //双重检测锁模式的懒汉式单例。 简称DCL懒汉式
    //主要目的是解决多线程并发单例失败问题。
    public static LazyMan getInstance(){
        if(lazyMan == null){
            synchronized (LazyMan.class){
                if(lazyMan == null){
                    lazyMan = new LazyMan();//不是一个原子性操作
//                    1.分配内存空间
//                    2.执行构造方法，初始化对象
//                    3.把这个对象指向这个空间
//
//                    期望的顺序是：123
//                    但是会有：132 A 的情况
//                    如果再来一个B，此时lazyMan还没有完成构造
                }
            }
        }
        return lazyMan;
    }
}

为了解决这个问题，需要加入volatile，变成原子性操作，改变代码如下：

   // private static LazyMan lazyMan;
    private volatile static LazyMan lazyMan;

静态内部类：

//静态内部类
public class Holder {
    private Holder(){
        
    }
    
    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }
    
    public static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }
}

注意：以上提到的这些单例，并不安全。反射会破坏这种单例模式。

对DCL懒汉模式增加反射，破解单例，代码如下：

//懒汉式单例
public class LazyMan {

    private LazyMan(){

    }
    
    private volatile static LazyMan lazyMan;

    //双重检测锁模式的懒汉式单例。 简称DCL懒汉式
    //主要目的是解决多线程并发单例失败问题。
    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 instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);
    }
}

运行结果：

 根据结果：如果是单例模式的话，说明两种结果是一致的。但是，这里结果不一致，说明反射会破坏单例模式，那对于这种反射，应该怎么去解决呢？在构造方法中增加判断，代码如下：

//懒汉式单例
public class LazyMan {

    private LazyMan(){

        synchronized (LazyMan.class){
            if(lazyMan != null){
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }
    }

    private volatile static LazyMan lazyMan;

    //双重检测锁模式的懒汉式单例。 简称DCL懒汉式
    //主要目的是解决多线程并发单例失败问题。
    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 instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);
    }
}

运行结果：

虽然加了一个判断，让反射无法破坏单例，但是对反射处进行改进，仍然可以对单例进行破坏，改进的代码如下所示：

//懒汉式单例
public class LazyMan {

    private LazyMan(){

        synchronized (LazyMan.class){
            if(lazyMan != null){
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }
    }

    private volatile static LazyMan lazyMan;

    //双重检测锁模式的懒汉式单例。 简称DCL懒汉式
    //主要目的是解决多线程并发单例失败问题。
    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 instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);
    }
}

结果如图所示：

针对这种情况，仍然有方法可以防止该反射的破坏，增加红绿灯。代码如下：

 

//懒汉式单例
public class LazyMan {

    private static boolean wuyinliang = false;

    private LazyMan(){

        synchronized (LazyMan.class){
            if(wuyinliang == false){
                wuyinliang = true;
            }else{
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }
    }

    private volatile static LazyMan lazyMan;

    //双重检测锁模式的懒汉式单例。 简称DCL懒汉式
    //主要目的是解决多线程并发单例失败问题。
    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 instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);
    }
}

结果如图所示：

枚举类型： 

public enum EnumSingle {
    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        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);
    }
}

枚举类型不细讲了，也能被破译，不过安全性更高

忍住，谁笑谁是谁儿子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单例模式的几种实现方式详解以及原理
weixin_51790763的博客
07-11 1123
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
浅谈单例模式
xiketangAndy的博客
11-01 223
前言 什么是单例模式？ 单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例（根据需要，也有可能一个线程中属于单例，如：仅线程上下文内使用同一个实例） 上面是百度百科给出的解释。 大家都知道，面向对象的思想就是我们可以把一个类实例很多次，每次实例出来的都是一个对象，意味着你可以创建很多个基于这个类的对象。 单例模式，说白了，就是这些对象本质都是同一个，整个程序中，不管在哪里用，使用的都是同一个实例对象。 如果我们创建了一个China类，我们可以一
谈谈java的单例模式吧
no problem的博客
03-19 162
传说中的GOF设计模式终于被我给拿下了，在我的编程进击之路中，面向对象的设计模式这团迷云也逐渐变得清晰起来，我相信随着以后我对她的使用的逐步加深，她将变得更加通透，更加清晰，将会成为我编程设计路上手握着的一把锋利的钢刀。 ...
通俗易懂的手写单例模式
qq_41893646的博客
01-20 375
这个是面试的时候经常会问到的，顺便让你手写一个单例模式 单例模式：一个类只创建一个实例，并且系统都使用这一个实例。 常用的单例模式有两种： 1 饿汉式的 // 饿汉式是 直接就只实例一个对象，你要用，我就返回给你 //但是有个问题，因为是提前写好的，可能会浪费空间，因为你占用了空间，但是可能没有起作用。 public class Hungry { //不使用就浪费 private byte[] data1 =new byte[1024*1024]; private byte[] d
设计模式之单例模式深究
weixin_33809981的博客
12-14 66
2019独角兽企业重金招聘Python工程师标准>>> ...
『 C++ 』单例模式与IO流
小侯宝的博客
08-13 924
单例模式（Singleton Pattern）是一种创建型设计模式，确保一个类在应用程序的生命周期内仅有一个实例，并提供一个全局访问点来访问该实例。单例模式主要目的是为了控制某些类的实例化以避免产生多个实例，从而节省资源和避免数据不一致问题。单例模式的核心要点包括唯一性、全局访问点和加载方式。常见的加载方式有饿汉加载和懒汉加载。饿汉加载在程序启动时即初始化实例，线程安全但可能浪费资源；懒汉加载在需要时才初始化，节约内存且初始速度较快，但需要注意线程安全问题。
c++基础：37.单例模式
m0_49024067的博客
08-13 239
这是常规方式，每次使用都需要调用GetInstance（）函数。这里可以使用另一种方法。
【单例模式（饿汉式和懒汉式）】
Pumpkin_O的博客
08-16 317
单例模式就是一个类只能有一个实例，并且提供一个访问它的全局访问点。通常通过来实现只能通过类的内部创建实例。
C++ | 深入理解C++中的特殊类设计和单例模式(懒汉模式、饿汉模式)
LiHongyu05的博客
08-12 543
在C++编程中，类的设计往往需要满足特定的需求和约束。特殊类设计模式提供了一种方法来实现这些需求，确保类的使用既安全又高效。本文将探讨几种常见的特殊类设计方式，包括不可拷贝类、只能在堆上创建对象的类、只能在栈上创建对象的类、不可继承的类以及单例模式。
C++ 单例模式
m0_65143871的博客
08-12 401
单例模式是一种设计模式.什么是设计模式呢?设计模式是一种代码设计经验的总结.单例模式就是其中的一种模式.单例模式用于期望全局中类的实例化只有一个的场景.我们只要把类的构造函数私有化,在类外部就无法实例化类对象了.单例模式又分为饱汉模式和饿汉模式.
java多线程（初阶）
2201_76027754的博客
08-13 627
java多线程初阶
C++ 特殊类设计以及单例模式
weixin_64099089的博客
08-16 778
C++一些特殊类的设计
C++面向对象单例模式禁止拷贝、禁止赋值操作（=delete）
Dontla的博客
08-13 520
总的来说，这种做法是对单例设计模式的一个强化，确保了类的全局控制和资源管理的安全性。对象赋值给另一个现有的对象。这是一种常见的做法，特别是在设计单例模式的类时。这行代码意味着你不能使用拷贝构造函数来创建一个。这些语句的作用是禁止拷贝和赋值操作对。这行代码阻止了将一个。
【C++】设计模式 — 从零开始认识单例模式
JLX_1的博客
08-14 970
本文讲解了设计模式的单例模式，详细讲解了饿汉模式和懒汉模式的实现
C++参悟-单例模式
洪源兄
08-15 523
单例模式（Single Pattern）是一种常用的软件设计模式，它属于创建型模式。单例模式的定义是确保一个类仅有一个实例，并提供一个全局访问点来获取这个唯一的实例。该模式的核心在于控制实例的数目，使得在整个系统中，该类只被实例化一次。
JAVA进阶补充
2301_80150315的博客
08-15 874
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 568
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1042
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
android 安全架构深究 电子书
07-28
安卓安全架构是指为了保护安卓设备和应用程序的安全性而制定的一系列安全措施和机制。它的设计目标是确保设备和用户的数据安全，防范恶意软件和黑客攻击，保护用户的隐私。 安卓安全架构主要包括以下几个方面： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值