八种单例模式

S-X-S2024-05-27 5:06

文章目录

1.单例模式基本介绍

1.介绍
2.单例模式八种方式

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

1.基本步骤
1.构造器私有化（防止new）
2.类的内部创建对象
3.向外暴露一个静态的公共方法
2.代码实现
java 复制代码 
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;
    }
}
3.优缺点分析

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

1.代码实现
java 复制代码 
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.优缺点分析

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

1.代码实现
java 复制代码 
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.优缺点分析

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

1.代码实现
java 复制代码 
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.优缺点分析

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

1.介绍
2.优缺点分析

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

1.代码实现
java 复制代码 
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. 直接赋值：

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

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

    java 复制代码 
    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 包中的原子类。例如，对一个计数器进行增加操作：

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

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

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

总结

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

3.优点分析

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

1.前置知识
1.外部类被装载，静态内部类不会被装载
2.当调用静态内部类的属性时，静态内部类会被装载且只会被装载一次
3.在类装载的时候是线程安全的
2.代码实现
java 复制代码 
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.优点分析

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

1.代码实现
java 复制代码 
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.优缺点分析

10.单例模式总结

1.Runtime就使用了饿汉式的单例模式
2.注意事项和细节
相关推荐
狂奔的sherry1 天前
单例模式（巨通俗易懂）普通单例，懒汉单例的实现和区别，依赖注入......
开发语言·c++·单例模式
晨星05272 天前
软件设计模式之单例模式
单例模式·设计模式
code bean4 天前
【wpf】WPF开发避坑指南：单例模式中依赖注入导致XAML设计器崩溃的解决方案
单例模式·wpf
是三好6 天前
单例模式（Singleton Pattern）
java·开发语言·算法·单例模式
青春易逝丶6 天前
单例模式
单例模式
YA3336 天前
java设计模式一、单例模式
java·单例模式·设计模式
枫景Maple6 天前
Unity中多线程与高并发下的单例模式
unity·单例模式·游戏引擎
iiiiaaiashah7 天前
单例模式的mock类注入单元测试与友元类解决方案
java·开发语言·单例模式
jingfeng51410 天前
线程池及线程池单例模式
linux·开发语言·单例模式
Brookty11 天前
深入解析Java并发编程与单例模式
java·开发语言·学习·单例模式·java-ee
热门推荐
012025 年高教社杯全国大学生数学建模竞赛C 题 NIPT 的时点选择与胎儿的异常判定 完整成品思路模型代码分享，全网首发高质量！！！022025年数学建模国赛C题超详细解题思路03UV安装并设置国内源042025全国大学生数学建模C题保姆级思路模型（持续更新）：NIPT 的时点选择与胎儿的异常判定05不再让Windows更新！&Edge游戏助手卸载及关闭自动更新062025高教社杯国赛数学建模选题建议+初步分析07KGG转MP3工具|非KGM文件|解密音频082025国赛B题保姆级教程思路分析 碳化硅外延层厚度的确定09教你如何认证 Gemini 教育优惠的二次验证，薅个 1年的 Gemini Pro 会员10jdk21下载、安装（Windows、Linux、macOS）