当前位置：首页 > news >正文

java设计模式一、单例模式

news 2025/9/2 8:33:51

什么是单例模式

单例模式是一种常用的软件设计模式，它的核心思想是确保一个类只有一个实例，并且提供一个全局访问点来获取这个实例。简单来说，就是“只创建一个对象，或者每次使用的对象都是同一个对象”。

这种模式在许多场景下非常有用，比如配置信息管理、线程池、数据库连接池、日志对象等，这些情况下我们需要确保全局只有一个实例存在，以避免资源浪费或状态不一致的问题。

单例模式的构建原则

要实现一个正确的单例模式，需要遵循以下几个重要原则：

私有构造方法 - 防止类被通过常规的方法实例化，确保只能通过特定方式创建实例
以静态方法或枚举返回实例 - 提供统一的访问点，保证实例的唯一性
确保多线程环境下的安全 - 特别是在创建实例时需要保证线程安全
防止反序列化破坏单例 - 在序列化/反序列化场景下，确保不会重复构建对象

单例模式的创建方式

主动处理方式

synchronized关键字 - 通过同步机制保证线程安全
volatile关键字 - 保证变量的可见性和防止指令重排序
CAS(Compare And Swap) - 通过原子操作实现无锁线程安全

JVM机制保障

静态初始化器 - 在静态字段或static{}块中的初始化器初始化数据时
final字段访问 - 访问final字段时的特殊处理
线程创建前对象创建 - 在创建线程之前创建对象
对象可见性 - 线程可以看见它将要处理的对象

单例模式的分类与实现

下面是单例模式的主要分类示意图：

在这里插入图片描述

1. 静态常量方式（饿汉式）

public class Singleton_1 {public static ArrayList<String> list = new ArrayList<>();/*** 在JVM初始化的时候就会加载静态变量* 常用于保存全局配置或共享数据* 由YA33编写*/
}

特点：

类加载时就完成初始化，避免了线程同步问题
没有达到懒加载的效果，如果从未使用过这个实例，会造成内存浪费

2. 饿汉模式

public class Singleton_2 {// 在类加载时就创建实例private static Singleton_2 instance = new Singleton_2();// 私有化构造方法，不对外提供private Singleton_2() {// 初始化代码}// 返回已经创建好的对象public static Singleton_2 getInstance() {return instance;}/*** 在应用启动的时候就创建对象* 类似于一个很饿的人，上来就要吃饭* 由YA33编写*/
}

优缺点分析：

优点：写法简单，类加载时就完成实例化，避免了线程同步问题
缺点：没有达到懒加载的效果，如果从始至终从未使用过这个实例，则会造成内存的浪费

3. 懒汉模式（基础版）

public class Singleton_3 {private static Singleton_3 instance;private Singleton_3() {// 初始化代码}public static Singleton_3 getInstance() {if (instance == null) {instance = new Singleton_3();}return instance;}/*** 只有当对象不存在的时候才会去创建，存在就不创建了* 就像一个吃饱饭的人，只有饿了才会去备饭* 但是如果有多个人同时来创建的话可能会同时创建多个* 所以它是线程不安全的* 由YA33编写*/
}

线程安全问题说明：
在多线程环境下，如果两个线程同时判断instance == null，可能会创建两个实例，违反了单例原则。

4. 双检锁懒汉模式（DCL）

public class Singleton_4 {// 使用volatile保证可见性和防止指令重排private static volatile Singleton_4 instance;private Singleton_4() {// 初始化代码}public static Singleton_4 getInstance() {if (instance == null) { // 第一次检查synchronized (Singleton_4.class) { // 加锁if (instance == null) { // 第二次检查instance = new Singleton_4();}}}return instance;}/*** 双检锁模式既实现了延迟加载，又保证了线程安全* 同时减少了同步代码块的使用，提高了效率* 由YA33编写*/
}

为什么要使用volatile？
对象的创建过程分为三步：

在堆中开辟空间
实例化各种参数
将对象的指针指向堆内存的空间

如果没有volatile，可能会发生指令重排，导致其他线程获取到未完全初始化的实例。

双检锁机制的执行流程如下：

在这里插入图片描述

5. 静态内部类方式

public class Singleton_5 {// 私有构造函数private Singleton_5() {// 初始化代码}// 静态内部类private static class SingletonHolder {private static final Singleton_5 INSTANCE = new Singleton_5();}// 获取实例public static Singleton_5 getInstance() {return SingletonHolder.INSTANCE;}/*** 不需要加锁，可以保证线程安全，实现了延迟加载* 由JVM保证线程安全性，在类进行初始化时，其他线程无法进入* 缺点是不能传递参数* 由YA33编写*/
}

工作原理：
静态内部类不会在外部类加载时立即加载，而是在调用getInstance()方法时才会加载SingletonHolder类并初始化INSTANCE，这既实现了懒加载，又由JVM保证了线程安全。

6. CAS方式实现

import java.util.concurrent.atomic.AtomicReference;public class Singleton_6 {private static final AtomicReference<Singleton_6> INSTANCE = new AtomicReference<>();private Singleton_6() {// 初始化代码}public static Singleton_6 getInstance() {for (;;) {Singleton_6 current = INSTANCE.get();if (current != null) {return current;}current = new Singleton_6();if (INSTANCE.compareAndSet(null, current)) {return current;}}}/*** 使用CAS(Compare And Swap)原子操作实现无锁线程安全* 适合高并发场景，避免了锁的开销* 但在竞争激烈的情况下可能会多次创建实例(但最终只会有一个成功)* 由YA33编写*/
}

CAS原理说明：
CAS是一种无锁算法，它包含三个操作数：内存位置(V)、预期原值(A)和新值(B)。如果内存位置的值与预期原值相匹配，处理器会自动将该位置值更新为新值，否则不做操作。

7. 枚举方式

public enum Singleton_7 {INSTANCE;// 可以添加任意方法public void doSomething() {System.out.println("Hello World");}/*** 枚举方式实现单例是《Effective Java》作者Joshua Bloch推荐的方式* 它不仅能避免多线程同步问题，还能防止反序列化重新创建新的对象* 绝对防止多次实例化，是更简洁、安全的单例实现方式* 由YA33编写*/
}

枚举单例的优势：

写法简单
线程安全有保障
防止反序列化破坏单例
防止反射攻击

如何选择单例实现方式

根据不同的场景，可以选择合适的单例实现方式：

实现方式	线程安全	懒加载	性能	防序列化破坏	适用场景
饿汉式	是	否	高	否	简单应用，实例小且一定会用到
懒汉式(同步)	是	是	低	否	不推荐使用
双检锁	是	是	中	否	需要懒加载且对性能有一定要求
静态内部类	是	是	高	否	需要懒加载且实现简单
枚举	是	否	高	是	最佳实践，推荐使用
CAS	是	是	不定	否	高并发场景，避免锁竞争