八种单例模式

最新推荐文章于 2024-06-16 23:38:56 发布
最新推荐文章于 2024-06-16 23:38:56 发布
阅读量1.1k 收藏 5
点赞数 8
分类专栏： 设计模式 文章标签： 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64637029/article/details/139220832
版权

文章目录

1.单例模式基本介绍

1.介绍

image-20240526192046799

2.单例模式八种方式

image-20240526192132094

2.饿汉式（静态常量，推荐）

1.基本步骤
1.构造器私有化（防止new）
2.类的内部创建对象
3.向外暴露一个静态的公共方法
2.代码实现
package com.sun.type1;

/**
 * Description: 单例模式饿汉式（静态变量）
 * @Author sun
 * @Create 2024/5/26 19:28
 * @Version 1.0
 */
public class Singleton01 {
    public static void main(String[] args) {
        // 通过公有的静态方法，获取实例
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance1 == instance); // 返回的是true
    }
}

class Singleton {

    // 1.构造器私有化
    private Singleton() {}

    // 2.本类的内部创建对象实例
    private final static Singleton instance = new Singleton();

    // 3.暴露一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

image-20240526194327006

3.优缺点分析

image-20240526194535444

3.饿汉式（静态代码块，推荐）

1.代码实现
package com.sun.type1;

/**
 * Description: 单例模式饿汉式（静态代码块）
 * @Author sun
 * @Create 2024/5/26 19:49
 * @Version 1.0
 */
public class Singleton02Test {
    public static void main(String[] args) {
        // 通过公有的静态方法，获取实例
        Singleton02 instance = Singleton02.getInstance();
        Singleton02 instance1 = Singleton02.getInstance();
        System.out.println(instance1 == instance); // 返回的是true
    }
}

class Singleton02 {

    // 1.构造器私有化
    private Singleton02() {}

    // 2.本类的内部有一个静态属性
    private static Singleton02 instance;

    // 3.使用静态代码块为静态属性初始化
    static {
        instance = new Singleton02();
    }

    // 4.暴露一个公有的静态方法，返回实例对象
    public static Singleton02 getInstance() {
        return instance;
    }
}
2.优缺点分析

image-20240526200000545

4.懒汉式（线程不安全，实际开发不要使用）

1.代码实现
package com.sun.type3;

/**
 * Description: 单例模式懒汉式（线程不安全）
 * @Author sun
 * @Create 2024/5/26 20:02
 * @Version 1.0
 */
public class Singleton03Test {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance1 == instance);
    }
}

class Singleton {

    // 1.构造器私有化
    private Singleton() {}

    // 2.静态属性，存放本类对象
    private static Singleton instance;

    // 3.静态的公有方法，当使用到该方法时才会去创建instance
    public static Singleton getInstance() {
        // 当静态属性没有被赋值的时候再去创建
        if (instance == null) {
            instance = new Singleton();
        }
        // 如果这个静态属性被初始化过了，就直接返回，保证是单例的
        return instance;
    }
}
2.优缺点分析

image-20240526201118772

5.懒汉式（线程安全，同步方法，实际开发不推荐使用）

1.代码实现
package com.sun.type4;

/**
 * Description: 单例模式懒汉式（线程安全，同步方法）
 * @Author sun
 * @Create 2024/5/26 20:15
 * @Version 1.0
 */
public class Singleton04Test {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance1 == instance);
    }
}

class Singleton {

    // 1.构造器私有化
    private Singleton() {}

    // 2.静态属性，存放本类对象
    private static Singleton instance;

    // 3.静态的公有方法，当使用到该方法时才会去创建instance，使用synchronized实现线程安全
    public static synchronized Singleton getInstance() {
        // 当静态属性没有被赋值的时候再去创建
        if (instance == null) {
            instance = new Singleton();
        }
        // 如果这个静态属性被初始化过了，就直接返回，保证是单例的
        return instance;
    }
}
2.优缺点分析

image-20240526202034683

6.懒汉式（线程安全，同步代码块，解决不了同步问题）

1.介绍

image-20240526202352115

2.优缺点分析

image-20240526202512379

7.双重检查（推荐使用）

1.代码实现
package com.sun.type6;

/**
 * Description: 双重检查
 * @Author sun
 * @Create 2024/5/26 20:15
 * @Version 1.0
 */
public class Singleton06Test {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance1 == instance);
    }
}

class Singleton {

    // 1.构造器私有化
    private Singleton() {}

    // 2.静态属性，存放本类对象，使用volatile防止指令重排序
    private static volatile Singleton instance;

    // 3.静态的公有方法，当使用到该方法时才会去创建instance
    public static Singleton getInstance() {
        // 先检查一次静态属性是否为空，这样可以过滤掉一部分
        if (instance == null) {
            // 如果为空，则进入同步代码块创建对象，由于还是会有多个线程进来，所以在内部需要二次检查
            synchronized (Singleton.class) {
                // 在此完成双重检查
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        // 如果这个静态属性被初始化过了，就直接返回，保证是单例的
        return instance;
    }
}
2.关于volatile关键字
使用 volatile 的常见场景

  1. 直接赋值：

    • 设置标志位，如控制线程的开始或停止。
    • 单个配置值的更新，这个值被多个线程读取。

    例如，一个线程控制开关：

    public class TaskRunner implements Runnable {
    private volatile boolean stop = false;

    public void run() {
        while (!stop) {
            // 执行任务
        }
    }

    public void stop() {
        stop = true;
    }
}

  2. 单一读取操作：

    • 在这种情况下，volatile 保证了每次读取操作都从主内存中获取最新值，而不是从线程的本地缓存。
复合操作的限制

如果操作涉及到对变量的读取、修改和写回（如 a++），则 volatile 不能保证操作的原子性。这类操作需要使用 synchronized 或 java.util.concurrent.atomic 包中的原子类。例如，对一个计数器进行增加操作：

public class Counter {
    private volatile int count = 0; // 这是错误的做法，对于 count++ 操作

    public void increment() {
        count++; // 这不是线程安全的
    }
}

在上面的代码中，count++ 操作实际上是三个步骤：读取 count 的当前值，增加 1，然后写回新值。这三个步骤不是原子操作，因此即使 count 被声明为 volatile，在多线程环境中也可能导致不正确的结果。

总结

总之，当你的需求仅限于确保多线程之间对单个变量直接赋值操作的可见性和有序性时，使用 volatile 是合适的。然而，对于需要多个步骤或基于当前值的修改的操作，你需要使用更强的同步机制。

3.优点分析

image-20240526204442702

8.静态内部类实现（推荐使用）

1.前置知识
1.外部类被装载，静态内部类不会被装载
2.当调用静态内部类的属性时，静态内部类会被装载且只会被装载一次
3.在类装载的时候是线程安全的
2.代码实现
package com.sun.type7;

/**
 * Description: 单例模式（静态内部类实现）
 * @Author sun
 * @Create 2024/5/26 20:51
 * @Version 1.0
 */
public class Singleton07Test {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance1 == instance);
    }
}

class Singleton {

    // 1.构造器私有化
    private Singleton() {}

    // 2.一个静态内部类，该类有一个静态属性，存放外部类的对象
    private static class SingletonInstance {
        public static final Singleton INSTANCE = new Singleton();
    }

    // 3.静态的公有方法，当要使用时调用内部类的静态属性，此时静态内部类会被装载，且只会被装载一次
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}
3.优点分析

image-20240526210255702

9.枚举实现（推荐使用）

1.代码实现
package com.sun.type8;

/**
 * Description: 单例模式（静态内部类实现）
 * @Author sun
 * @Create 2024/5/26 20:51
 * @Version 1.0
 */
public class Singleton08Test {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance2 == instance);
    }
}

enum Singleton {
    // 这个就相当于调用无参构造创建了这个类的一个对象，可以实现单例模式
    INSTANCE;
}
2.优缺点分析

image-20240526210742011

10.单例模式总结

1.Runtime就使用了饿汉式的单例模式

image-20240526211234759

2.注意事项和细节

image-20240526211508150

S-X-S
关注
  • 8
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
单例模式的八种写法
样young的博客
08-02 526
1、饿汉式（静态常量）[可用] public class Singleton { private final static Singleton INSTANCE = new Singleton(); private Singleton(){} public static Singleton getInstance(){ return INSTANCE; } } 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。 缺点
第八课 单例模式1
08-03
1.单例模式可以构建出全局维护使用的单一实例对象，避免了变量全局污染 2.单例模式的单例对象只会在实例化的时候生成一次，之后进行返回，减少了不必要的 3.单例模
一文简单了解八种单例模式
a760352276的博客
07-31 131
​ 一文简单了解八种单例模式1、饿汉式（静态常量）[可用]2、饿汉式（静态代码块）[可用]3、懒汉式（线程不安全）[不可用]4、懒汉式（线程安全，同步方法）[不推荐使用]5、懒汉式（线程不安全，同步代码块）[不可用]6、双重检查[推荐使用]7、静态内部类[推荐使用]8、枚举类[推荐使用]八种单例模式的小结：各种写法的使用场合：面试常见问题： 首先我们通过单例模式的作用来看为什么会出现单例模式。单例模式的出现可以节省内存和计算、保证结果正确、方便管理。其主要适用于：无状态的工具类（日志类等提供的服务都是一样的
单例模式的八种类型
qq_40941016的博客
08-09 3948
单例模式的八种类型 1. 单例设计模式介绍 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。 比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session 对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory就够，这是就会使用到单例模式。 2. 单例模式有八种方式： 饿汉式(静态常量) 饿汉式（静态代码块）
单例模式（两种）
qq_54773998的博客
03-31 1370
目录 一，概念 二，应用实例 三，饿汉模式 四，懒汉模式（单线程） 五，懒汉模式（多线程且效率低） 六，懒汉模式（双重校验锁） 七，破坏单例模式 八，总结 一，概念 单例模式是指在内存中只会创建且仅创建一次对象的设计模式 在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象 二，应用实例 在jdbc操作时，使用了DataSource（数据库连接池） 三，饿汉模式 饿汉.
设计模式之单例模式（附常见八种单例模式）
云祁QI
09-30 1162
文章目录单例设计模式介绍单例设计模式八种方式饿汉式（静态常量）饿汉式（静态代码块）懒汉式(线程不安全)懒汉式(线程安全，同步方法)双重检查静态内部类枚举单例模式在JDK 应用的源码分析单例模式注意事项和细节说明 单例设计模式介绍 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。 比如Hibernate...
23种设计模式之单例模式
G823909的博客
11-14 319
通过上述八种单例模式的实现，我们可以总结出推荐使用的单例模式有双重检查静态内部类枚举。
单例模式（八种方法分析）
can_meng_yun的博客
07-14 597
所谓的单例设计模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。
单例模式（八种单例模式）
weixin_43885970的博客
04-07 179
什么是单例？ 确保一个类在任何情况下（任何情况：多线程、并发、反射调用构造器）只有一个实例，并提供一个全局访问点。单例会因此其所有的方法、属于创建型模式。 单例的几种写法？ 懒汉、饿汉、枚举、double check 、内部类。 饿汉式：不管用不用，都先赋值。优点：线程安全、逻辑简单、空间换时间；缺点：如果这种写法被大量使用，导致内存开销增加。 懒汉式：即用即赋值，不调用不赋值。第一次使用时先判断...
Java中八种单例模式以及各自的优缺点
qq_25017839的博客
04-28 546
1、饿汉式（静态常量）[可用] public class Singleton { private final static Singleton INSTANCE = new Singleton(); private Singleton(){} public static Singleton getInstance(){ return INS...
单例模式的八种写法比较
03-19
android资料 单例模式的八种写法比较 单例模式是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。
第五讲单例模式
09-15
软件中的四人帮，有01工厂模式，02工厂方法模式03抽象工厂04工厂模式的应用05单列模式
java23种设计模式
10-17
004单例模式) m) x8 z7 t( q5 P4 }4 u# v 005工厂模式+ [% H7 o% z% F7 b' N* n# {& K; _ 006命令模式9 D% c+ V8 l$ {* n, y/ N 007适配器模式 008外观模式5 d3 j: D% K3 ` t 009模板模式 010迭代器模式 011组合模式...
设计模式PPT.rar
08-27
01第一讲简单工厂模式 02第二讲工厂方法模式 03第三讲抽象工厂模式 04第四讲工厂模式在开发中的运用 05第五讲单例模式 06第六讲原型模式 07第七讲建造者模式 08第八讲装饰模式 09第九讲策略模式 10第十讲观察者模式 ...
单例模式、工厂模式 c++关键字 static
霍迪迪的博客
06-11 1133
在头文件中使用extern和static声明变量，可以让多个源文件共享同一变量的声明，但每个使用该声明的源文件需要有一个独立的定义（没有static），以避免多重定义错误。：在文件作用域声明的静态变量（即在函数外部，但用static修饰），其作用范围限制在定义它的源文件内，即它是“内部链接”的。我们可以通过工厂类可以实例化圆形 和正方形，但每次用工厂类的时候，我们不需要每次都实例化一个工厂，因此工厂类就用到了单例模式，使工厂在整个系统的生命周期唯一，避免多次创建。所有类实例共享同一个静态成员变量的副本。
设计模式：单例模式
wuxiaoyu0806的博客
06-10 981
o文件中包含了代码和数据的符号信息，以及未初始化变量的符号和大小（在.bss段中），已初始化变量的符号和初始值（在.data段中）。程序执行前：.o文件中的符号还没有具体的内存地址，但已经安排到相应的段中等待链接和加载。加载时：操作系统会将.bss段清零，将.data段加载到内存并初始化相应的变量。通过以上描述，你可以更清晰地了解静态成员变量在编译、链接和加载过程中的处理。运行时；
Spring MVC的控制器是不是单例模式
m0_47743175的博客
06-12 460
Spring MVC的控制器是不是单例模式,如果是,有什么问 题,怎么解决？
Qt实现单例模式：Q_GLOBAL_STATIC和Q_GLOBAL_STATIC_WITH_ARGS
最新发布
红军不怕远征难，万水千山只等闲
06-16 587
} \从上述代码可以看出：1）根据不同的 NAME，生成了不同的命名空间，虽然对象创建函数、多线程同步变量guard的名字一样，但是是在不同的命名空间，因此生成的QGlobalStatic也是不一样的，其实这个也是实现技巧。2）QBasicAtomicInt 是 原子操作，是线程安全的，它的介绍在这里就不在赘述了，不明白的地方请自行查阅。3）Q_GLOBAL_STATIC是Q_GLOBAL_STATIC_WITH_ARGS的特例。
默写两种单例模式 java
06-14
在Java中，单例模式是一种常用的软件设计模式，用于确保一个类只有一个实例，并提供一个全局访问点。以下是两种常见的单例模式实现： 1. **懒汉式单例模式**（也称为线程不安全的单例模式）： 这种实现只有在首次...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

S-X-S

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值