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

单例模式：确保一个类只有一个实例

news 来源：原创 2025/8/27 5:24:56

引言

1. 单例模式的核心思想

2. 单例模式的实现方式

2.1 饿汉式单例

2.2 懒汉式单例

2.3 线程安全的懒汉式单例

2.4 双重检查锁定（Double-Checked Locking）

2.5 静态内部类实现单例

2.6 枚举实现单例

3. 单例模式的使用场景

4. 单例模式的优缺点

优点：

缺点：

5. 总结

引言

单例模式（Singleton Pattern）是设计模式中最简单且最常用的创建型模式之一。它的核心思想是确保一个类只有一个实例，并提供一个全局访问点来获取该实例。单例模式在许多场景中非常有用，例如配置管理、线程池、数据库连接池等。

1. 单例模式的核心思想

单例模式的核心思想是：

私有化构造函数：防止外部通过 new 关键字创建实例。
提供一个静态方法：用于获取类的唯一实例。
确保唯一性：在整个应用程序生命周期中，类的实例只有一个。

2. 单例模式的实现方式

单例模式有多种实现方式，每种方式都有其优缺点。以下是几种常见的实现方式：

2.1 饿汉式单例

饿汉式单例在类加载时就创建实例，因此是线程安全的。

public class Singleton {// 在类加载时创建实例private static final Singleton INSTANCE = new Singleton();// 私有化构造函数private Singleton() {}// 提供全局访问点public static Singleton getInstance() {return INSTANCE;}
}

饿汉式是最简单的单例模式的写法，保证了线程的安全，在很长的时间里，我都是饿汉模式来完成单例的，因为够简单，后来才知道饿汉式会有一点小问题，看下面的代码：

 public class Hungry {private byte[] data1 = new byte[1024];private byte[] data2 = new byte[1024];private byte[] data3 = new byte[1024];private byte[] data4 = new byte[1024];private Hungry() {}private final static Hungry hungry = new Hungry();public static Hungry getInstance() {return hungry;}}

在Hungry类中，我定义了四个byte数组，当代码一运行，这四个数组就被初始化，并且放入内存了，如果长时间没有用到getInstance方法，不需要Hungry类的对象，这不是一种浪费吗？我希望的是只有用到了 getInstance方法，才会去初始化单例类，才会加载单例类中的数据。所以就有了第二种单例模式：懒汉式。

优点：

实现简单，线程安全。

缺点：

如果实例未被使用，会造成资源浪费。

2.2 懒汉式单例

懒汉式单例在第一次调用 getInstance() 时才创建实例。

public class LazyMan {private LazyMan() {System.out.println(Thread.currentThread().getName()+"Start");}private static LazyMan lazyMan;public static LazyMan getInstance() {if (lazyMan == null) {lazyMan = new LazyMan();}return lazyMan;}// 测试并发环境，发现单例失效public static void main(String[] args) {for (int i = 0; i < 10; i++) {new Thread(()->{LazyMan.getInstance();}).start();}}}

缺点：

线程不安全，多个线程可能同时进入 if (instance == null) 条件，导致创建多个实例。

2.3 线程安全的懒汉式单例

通过在 getInstance() 方法上加锁，可以解决懒汉式单例的线程安全问题。

public class LazyMan {private LazyMan() {}private static LazyMan lazyMan;public static LazyMan getInstance() {if (lazyMan == null) {synchronized (LazyMan.class) {if (lazyMan == null) {lazyMan = new LazyMan();}}}return lazyMan;}}

保证了线程的安全性，又符合了懒加载，只有在用到的时候，才会去初始化，调用效率也比较高，但是这种写法在极端情况还是可能会有一定的问题。因为：

lazyMan = new LazyMan();

不是原子性操作，至少会经过三个步骤：

1. 分配对象内存空间

2. 执行构造方法初始化对象

3. 设置instance指向刚分配的内存地址，此时instance ！=null；

由于指令重排，导致A线程执行 lazyMan = new LazyMan();的时候，可能先执行了第三步（还没执行第二步），此时线程B又进来了，发现lazyMan已经不为空了，直接返回了lazyMan，并且后面使用了返回的lazyMan，由于线程A还没有执行第二步，导致此时lazyMan还不完整，可能会有一些意想不到的错误，所以就有了下面一种单例模式。

2.4 双重检查锁定（Double-Checked Locking）

双重检查锁定是一种优化后的线程安全懒汉式单例实现方式。

这种单例模式只是在上面DCL单例模式增加一个volatile关键字来避免指令重排：

 public class LazyMan {private LazyMan() {}private volatile static LazyMan lazyMan;public static LazyMan getInstance() {if (lazyMan == null) {synchronized (LazyMan.class) {if (lazyMan == null) {lazyMan = new LazyMan();}}}return lazyMan;}
}

优点：

线程安全，且只有在第一次创建实例时加锁，性能较好。

注意：

必须使用 volatile 关键字，防止指令重排序导致的问题。

2.5 静态内部类实现单例

静态内部类实现单例是一种优雅且线程安全的方式。

public class Singleton {private Singleton() {}private static class SingletonHolder {private static final Singleton INSTANCE = new Singleton();}public static Singleton getInstance() {return SingletonHolder.INSTANCE;}
}

优点：

线程安全，且只有在调用 getInstance() 时才会加载 SingletonHolder 类，实现懒加载。

2.6 枚举实现单例

枚举实现单例是《Effective Java》推荐的方式，它天然支持线程安全和防止反射攻击。

public enum Singleton {INSTANCE;public void doSomething() {System.out.println("Doing something...");}
}

优点：

线程安全，代码简洁，防止反射和序列化破坏单例。

3. 单例模式的使用场景

单例模式适用于以下场景：

全局配置管理：例如读取配置文件，确保配置信息全局唯一。
数据库连接池：确保连接池只有一个实例，避免资源浪费。
日志管理：确保日志记录器全局唯一。
线程池：确保线程池的唯一性，避免重复创建线程。

4. 单例模式的优缺点

优点：

节省资源：避免重复创建对象，减少内存开销。
全局访问点：方便对唯一实例的管理和访问。

缺点：

扩展性差：单例类通常难以扩展，因为其构造函数是私有的。
违背单一职责原则：单例类既负责创建实例，又负责业务逻辑。
测试困难：单例类的全局状态可能导致测试困难。

5. 总结

单例模式是一种简单但强大的设计模式，适用于需要全局唯一实例的场景。通过不同的实现方式（如饿汉式、懒汉式、双重检查锁定、静态内部类、枚举等），可以满足不同的需求。

在实际开发中，应根据具体场景选择合适的单例实现方式。如果需要懒加载且线程安全，推荐使用静态内部类或枚举实现；如果需要更高的性能，可以考虑双重检查锁定。

引言

1. 单例模式的核心思想

2. 单例模式的实现方式

2.1 饿汉式单例

2.2 懒汉式单例

2.3 线程安全的懒汉式单例

2.4 双重检查锁定（Double-Checked Locking）

2.5 静态内部类实现单例

2.6 枚举实现单例

3. 单例模式的使用场景

4. 单例模式的优缺点

优点：

缺点：

5. 总结

相关文章：