【设计模式】- 单例模式

最新推荐文章于 2025-01-03 15:10:01 发布
最新推荐文章于 2025-01-03 15:10:01 发布
阅读量147 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45039879/article/details/105525405
版权

1、饿汉式

//饿汉式单例:一进来就会创建对象，可能会浪费时间
public class Hungry {

    private Hungry(){

    }
	//创建对象
    public final static Hungry hungry = new Hungry();

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

2、懒汉式

1）基本的懒汉式

//懒汉式单例
public class Lazy {

    private Lazy(){
       System.out.println(Thread.currentThread().getName() + "lazy线程启动");
	}
        
	if (lazy!=null){
		throw new RuntimeException("不要试图用凡是破坏单例！");
	}
       
    private static Lazy lazy;

    public static Lazy getLazy(){
		if (lazy==null){
		lazy = new Lazy(); 
	}
        return lazy; 
    }

    //单线程下，没有问题，但是多线程会存在问题
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			new Thread(()->{
				lazy.getLazy();
			}).start();
		}
	}
}

2）解决多线程不安全加双重检测锁

//懒汉式单例
public class Lazy {

    private Lazy(){
		System.out.println(Thread.currentThread().getName() + "lazy线程启动");
   }

    private static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式，懒汉式，DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); 
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }

    //单线程下，没有问题，但是多线程会存在问题
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                lazy.getLazy();
            }).start();
        }
    }
}

3）针对懒汉式在创建对象时，不是原子性操作，避免指令重排，将属性定义为volatile类型（双重检测锁＋原子操作）

//懒汉式单例
public class Lazy {

    private Lazy(){
		System.out.println(Thread.currentThread().getName() + "lazy线程启动");
   }

    private volatile static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式，懒汉式，DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); //不是原子性操作，会发生指令重排现象，期望1-2-3
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A
                     *     B //此时lazy还没有构造，就返回了
                     *
                     * 所以避免指令重排，要加volatile(原子性操作)
                     */
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }

    //单线程下，没有问题，但是多线程会存在问题
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                lazy.getLazy();
            }).start();
        }
    }
}

4）初步解决反射破坏懒汉式（三重检测）

//懒汉式单例
//道高一尺魔高一丈
public class Lazy {

    private Lazy(){

        synchronized (Lazy.class){
			if (lazy!=null){
				throw new RuntimeException("不要试图用凡是破坏单例！");
			}
		}
    }

    private volatile static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式，懒汉式，DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); //不是原子性操作，会发生指令重排现象，期望1-2-3
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A
                     *     B //此时lazy还没有构造，就返回了
                     *
                     * 所以避免指令重排，要加volatile(原子性操作)
                     */
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }
    
    //反射
    public static void main(String[] args) throws Exception {

        Lazy instant = lazy.getLazy(); //懒汉式中拿到的对象

        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);//反射获取无参构造器
        declaredConstructor.setAccessible(true); //破坏权限无视构造器
        Lazy lazy = declaredConstructor.newInstance(); //反射构造的对象

        System.out.println(instant.hashCode());
        System.out.println(lazy.hashCode());
    }
}

5）如果两个对象都是用单例创建的，通过红绿灯解决

//懒汉式单例
//道高一尺魔高一丈
public class Lazy {

    //红绿灯
    private static boolean bool = false;

    private Lazy(){
        synchronized (Lazy.class){
            if (!bool){
                bool = true;
            }else{
                throw new RuntimeException("不要试图用凡是破坏单例！");
            }
        }

    }

    private volatile static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式，懒汉式，DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); //不是原子性操作，会发生指令重排现象，期望1-2-3
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A
                     *     B //此时lazy还没有构造，就返回了
                     *
                     * 所以避免指令重排，要加volatile(原子性操作)
                     */
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }

    //反射
    public static void main(String[] args) throws Exception {

        Lazy instant = lazy.getLazy(); //懒汉式中拿到的对象

        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);//反射获取无参构造器
        declaredConstructor.setAccessible(true); //破坏权限无视构造器
        Lazy lazy = declaredConstructor.newInstance(); //反射构造的对象
        Lazy lazy2 = declaredConstructor.newInstance(); //反射构造的对象
        System.out.println(lazy.hashCode());
        System.out.println(lazy2.hashCode());
    }
}

6）如果红绿灯标志被反射获取，用枚举解决

//懒汉式单例
//道高一尺魔高一丈
public class Lazy {

    //红绿灯
    private static boolean bool = false;

    private Lazy(){
        synchronized (Lazy.class){
            if (!bool){
                bool = true;
            }else{
                throw new RuntimeException("不要试图用凡是破坏单例！");
            }
//            if (lazy!=null){
//                throw new RuntimeException("不要试图用凡是破坏单例！");
//            }
        }

    }

    private volatile static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式，懒汉式，DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); //不是原子性操作，会发生指令重排现象，期望1-2-3
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A
                     *     B //此时lazy还没有构造，就返回了
                     *
                     * 所以避免指令重排，要加volatile(原子性操作)
                     */
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }

    //单线程下，没有问题，但是多线程会存在问题
//    public static void main(String[] args) {
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//                lazy.getLazy();
//            }).start();
//        }
//    }

    //反射
    public static void main(String[] args) throws Exception {

        Lazy instant = lazy.getLazy(); //懒汉式中拿到的对象

        Field bool = Lazy.class.getDeclaredField("bool"); //反射获取类中的字段
        bool.setAccessible(true); //破坏属性的私有权限

        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);//反射获取无参构造器
        declaredConstructor.setAccessible(true); //破坏权限无视构造器
        Lazy lazy = declaredConstructor.newInstance(); //反射构造的对象

        bool.set(instant,false); //给字段重新赋值

        Lazy lazy2 = declaredConstructor.newInstance(); //反射构造的对象

        System.out.println(instant.hashCode());
        System.out.println(lazy.hashCode());
        System.out.println(lazy2.hashCode());
    }
}

3、静态内部类实现

//静态内部类实现
public class Holder {

    private Holder(){

    }

    private static Holder getHolder(){
        return InnerClass.holder;
    }

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

4、枚举

//enum: 1.5出现的，本身也是一个class类
public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }

    public static void main(String[] args) throws Exception {

        EnumSingle e1 = EnumSingle.INSTANCE;
        
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle enumSingle = declaredConstructor.newInstance();

        System.out.println(e1);
        System.out.println(enumSingle);
    }
}
设计模式-单例模式-注册式单例模式-枚举式单例模式和容器式单例模式在Java中的使用示例
BADAO_LIUMANG_QIZHI的博客
10-28 1121
上面讲了单例模式的三种方式，另外还有一种注册式单例模式。
设计模式 - 单例模式
菜鸟小码的博客
08-09 1031
单例模式是一种常用的创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。这种模式对于那些需要频繁创建和销毁对象的场合非常有用，例如日志记录器、缓存管理器、数据库连接池等。本文将详细介绍单例模式的实现原理，并通过具体的Java代码示例来说明如何实现这一模式。
设计模式--单例模式
an760998254的博客
05-14 166
单例模式 认识单例模式使用单例模式注意点：饿汉式缺点：懒汉式 DCL缺陷：指令重排：静态内部类反射机制打破单例模式的线程安全。使用枚举实现单例模式：结论：单例模式在spring中的应用 使用单例模式注意点： 私有化构造方法 instance是singleton类的静态成员，它的初始值可以为null，也可以写成new Singleton(); getInstance是获取单例对象的方法 如果单例模式的初始值为null,还未构建，则构造单例对象并返回，一般用于懒汉模式 如果单例对象开始就被new Sin
一文带你玩转单例模式
qq_44613591的博客
11-08 296
单例模式 单例模式的特点 七种实现方法 破坏单例模式与解决方案 总结 单例模式 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意： 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例。 3、单例类必须给所有其他对象提供这一实
Java单例模式 以原子操作方式的实现
spice
07-08 365
[b]问题[/b] [color=red]不同Java虚拟机实现产生有引用未构造问题[/color] Java虚拟机初始化对象时，分析如下 SomeObject so = new SomeObject(); Java虚拟机JVM 指令 so ====> memory A步骤 . . =====> construct--执行构造 B步...
设计模式-单例模式
HL_LOVE_C的博客
01-03 1526
单例模式是一种设计模式，它。就像是在一个软件系统中，某些资源或者对象只需要存在一个就可以满足系统的需求，比如系统的配置管理器、数据库连接池等。通过单例模式，可以避免创建多个实例导致的资源浪费、数据不一致等问题。
设计模式-单例模式（Singleton）
miaoyl的博客
11-03 1230
Java 单例模式（Singleton）是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点。这种模式通常用于需要频繁创建和销毁的对象，例如数据库连接、线程池等。
设计模式-单例模式（Singleton Pattern）
weixin_60653563的博客
08-22 1589
单例模式。饿汉式单例；懒汉式；枚举式单例；容器式单例；ThreadLocal式单例。
Python设计模式 - 单例模式
mofei
05-04 1133
单例模式是一种创建型设计模式， 其主要目的是确保一个类只有一个实例， 并提供一个全局访问点来访问该实例。
C++：设计模式-单例模式
己亥谷雨
11-22 2043
通过方法获取单例实例，这是调用饿汉式单例的标准方式。由于饿汉式实例在程序启动时就被创建，所以你不需要显式地进行实例化操作。饿汉式：简单，适合不需要延迟初始化的场景，程序启动时就创建实例。懒汉式：适合需要延迟初始化的场景，但需要考虑线程安全。线程安全懒汉式：通过加锁保证线程安全，但可能带来性能开销。双重检查锁：线程安全，减少了加锁的频率，但实现复杂。静态局部变量：线程安全，简洁，现代 C++ 中推荐的单例实现方式。在现代 C++ 中，静态局部变量。
通过C++实现一个设计模式-单例模式.zip
02-18
单例模式（Singleton Pattern）是软件设计中的一种常用设计模式，它确保一个类只有一个实例，并且提供一个全局访问点。单例模式属于创建型模式，它在Java、C++、Python等多种编程语言中都有广泛的应用。单例模式的...
ava常用设计模式-单例模式
08-26
ava常用设计模式-单例模式 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，有以下特点： 1. 单例类只能有一个实例。 2. 单例类必须自己创建自己的唯一实例。 3. 单例类必须给所有其他对象提供这一...
通过C++实现设计模式-单例模式.rar
11-02
压缩包代码是一个简单的C++单例模式实现。 在这个例子中，Singleton 类有一个私有的构造函数和一个私有的析构函数，这防止了外部代码直接创建或销毁实例。getInstance 方法是一个静态方法，它返回一个指向 Singleton...
常见设计模式-单例模式
10-25
设计模式-单例模式 单例模式是一种常见的设计模式，它的主要作用是确保在内存中仅创建一次对象，并提供一个全局访问点。单例模式有两种类型：饿汉类型和懒汉类型。 饿汉类型的单例模式是在类加载时创建对象，例如...
毕业设计选题 -未来生鲜运输车设计.pptx
04-03
毕业设计选题 -未来生鲜运输车设计.pptx
基于樽海鞘算法优化的极限学习机回归预测及其与BP、GRNN、ELM的性能对比研究
04-03
内容概要：本文详细探讨了基于樽海鞘算法（SSA）优化的极限学习机（ELM）在回归预测任务中的应用，并与传统的BP神经网络、广义回归神经网络（GRNN）以及未优化的ELM进行了性能对比。首先介绍了ELM的基本原理，即通过随机生成输入层与隐藏层之间的连接权重及阈值，仅需计算输出权重即可快速完成训练。接着阐述了SSA的工作机制，利用樽海鞘群体觅食行为优化ELM的输入权重和隐藏层阈值，从而提高模型性能。随后分别给出了BP、GRNN、ELM和SSA-ELM的具体实现代码，并通过波士顿房价数据集和其他工业数据集验证了各模型的表现。结果显示，SSA-ELM在预测精度方面显著优于其他三种方法，尽管其训练时间较长，但在实际应用中仍具有明显优势。 适合人群：对机器学习尤其是回归预测感兴趣的科研人员和技术开发者，特别是那些希望深入了解ELM及其优化方法的人。 使用场景及目标：适用于需要高效、高精度回归预测的应用场景，如金融建模、工业数据分析等。主要目标是提供一种更为有效的回归预测解决方案，尤其是在处理大规模数据集时能够保持较高的预测精度。 其他说明：文中提供了详细的代码示例和性能对比图表，帮助读者更好地理解和复现实验结果。同时提醒使用者注意SSA参数的选择对模型性能的影响，建议进行参数敏感性分析以获得最佳效果。
2025年中国生成式AI大会PPT（4-1）
04-03
2025年中国生成式AI大会PPT（4-1）
无刷直流电机双闭环调速系统的Simulink建模与参数优化
最新发布
04-03
内容概要：本文详细介绍了基于Simulink平台构建无刷直流电机（BLDC）双闭环调速系统的全过程。首先阐述了双闭环控制系统的基本架构，即外层速度环和内层电流环的工作原理及其相互关系。接着深入探讨了PWM生成模块的设计，特别是占空比计算方法的选择以及三角波频率的设定。文中还提供了详细的电机参数设置指导，如转动惯量、电感、电阻等，并强调了参数选择对系统性能的影响。此外，针对PI控制器的参数整定给出了具体的公式和经验值，同时分享了一些实用的调试技巧，如避免转速超调、处理启动抖动等问题的方法。最后，通过仿真实验展示了系统的稳定性和鲁棒性，验证了所提出方法的有效性。 适用人群：从事电机控制研究的技术人员、自动化工程领域的研究生及科研工作者。 使用场景及目标：适用于需要深入了解和掌握无刷直流电机双闭环调速系统设计与优化的人群。主要目标是帮助读者学会利用Simulink进行BLDC电机控制系统的建模、仿真和参数优化，从而提高系统的稳定性和响应速度。 其他说明：文章不仅提供了理论知识，还包括了许多实践经验和技术细节，有助于读者更好地理解和应用相关技术。
西门子S7-1200 PLC与施耐德变频器Modbus通讯实现及调试技巧
04-03
内容概要：本文详细介绍了西门子S7-1200 PLC与施耐德ATV310/312变频器通过Modbus RTU进行通讯的具体实现步骤和调试技巧。主要内容涵盖硬件接线、通讯参数配置、控制启停、设定频率、读取运行参数的方法以及常见的调试问题及其解决方案。文中提供了具体的代码示例，帮助读者理解和实施通讯程序。此外，还强调了注意事项，如地址偏移量、数据格式转换和超时匹配等。 适合人群：从事工业自动化领域的工程师和技术人员，尤其是那些需要将西门子PLC与施耐德变频器进行集成的工作人员。 使用场景及目标：适用于需要通过Modbus RTU协议实现PLC与变频器通讯的工程项目。目标是确保通讯稳定可靠，掌握解决常见问题的方法，提高调试效率。 其他说明：文中提到的实际案例和调试经验有助于读者避免常见错误，快速定位并解决问题。建议读者在实践中结合提供的代码示例和调试工具进行操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值