单例模式（饿汉实现、懒汉实现）

最新推荐文章于 2025-07-12 21:48:22 发布

原创最新推荐文章于 2025-07-12 21:48:22 发布 · 1.1k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#java-ee #java #intellij-idea

Java 同时被 2 个专栏收录

76 篇文章

订阅专栏

JavaEE

41 篇文章

订阅专栏

本文详细介绍了Java中的单例模式实现，包括饿汉式和懒汉式。饿汉式在类加载时即创建单例，确保线程安全但可能浪费资源；懒汉式则在首次使用时创建，避免了不必要的资源消耗。针对懒汉式的线程安全问题，文章列举了从简单的线程安全版到双重检查锁定（DCL）的改进过程，解释了在多线程环境下可能存在的问题及解决方案，最终提出了使用volatile关键字来确保正确初始化的最终版单例实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

(MS)

单例模式具体的实现⽅式, 分成 "饿汉" 和 "懒汉" 两种：

● 饿汉⽅式：程序启动之后，里面创建单例对象。（线程安全，可能会造成资源浪费）

● 懒汉⽅式：当有程序调用单例对象的时候才初始化。（使⽤时才加载，可以避免资源不必要的浪费）

单例模式的实现：

无论是饿汉还是懒汉，实现的模式是一模一样的，分为3种：

        1. 创建一个私有的构造函数（为防止其他类直接new此对象）。

        2. 创建一个私有的属性对象。

        3. 创建一个公共的对外暴露的单例对象。

默认的懒汉模式是⾮线程安全的，使⽤要对懒汉进⾏优化，优化改进：

● 全局加锁（线程安全、性能⽐较低）

● 局部加锁（线程安全，双重效验）

1. 饿汉实现

程序执行起来之后，执行是一次性的，是线程安全的，会造成资源的浪费。

饿汉实现
public class DataSourceSingleton {
    //1. 提供私有的构造方法，（防止外部直接new对象）
    private DataSourceSingleton() {
    }
    
    //2. 创建一个私有的属性对象
    private static DataSourceSingleton dataSource = new DataSourceSingleton();
    
    //提供公共的对外的单例对象
    public static DataSourceSingleton getInstance() {
        return dataSource;
    }
}

2. 懒汉模式

为了解决饿汉模式造成的资源浪费，产生了懒汉模式。

① 单线程版本

单例模式——懒汉模式 1 单线程版本

public class DataSourceSingleton2 {
    // 1.私有的构造方法
    private DataSourceSingleton2() {
    }

    // 2.创建一个私有的属性
    private static DataSourceSingleton2 dataSource = null;

    // 3.创建一个对外提供访问的单例对象
    public  static DataSourceSingleton2 getInstance() {
        if (dataSource == null) { // 第一次访问
            dataSource = new DataSourceSingleton2();
        }
        return dataSource;
    }
}

此懒汉模式的实现是线程不安全的.

线程安全问题发⽣在⾸次创建实例时. 如果在多个线程中同时调⽤ getInstance ⽅法, 就可能导致创建出多个实例.

⼀旦实例已经创建好了, 后⾯再多线程环境调⽤ getInstance 就不再有线程安全问题了(不再修改 instance 了)。

② 线程安全版

单例模式——懒汉模式2 线程安全版
public class DataSourceSingleton3 {
    // 1.私有的构造方法
    private DataSourceSingleton3() {
    }

    // 2.创建一个私有的属性
    private static DataSourceSingleton3 dataSource;

    // 3.创建一个对外提供访问的单例对象
    public synchronized static DataSourceSingleton3 getInstance() {
        if (dataSource == null) { // 第一次访问
            //可能会出问题
            dataSource = new DataSourceSingleton3();
        }
        return dataSource;
    }
}

虽然线程安全，但给全局加锁，性能不好。

③ 线程安全改进版⼀

单例模式--懒汉模式3  线程安全改进版⼀
public class DataSourceSingleton4 {
    // 1. 私有的构造方法
    private DataSourceSingleton4() {

    }
    // 2. 私有的属性
    private static DataSourceSingleton4 dataSource = null;
    // 3. 公共的访问方法，得到单例对象
    public static DataSourceSingleton4 getInstance() {
        //在返回dataSourse的之前，要先判断，是不是第一次访问，如果是第一次访问，需要new一个对象,此时，存在线程安全问题

            if(dataSource == null) { // 大致分流状态
                synchronized (DataSourceSingleton4.class) {
                    dataSource = new DataSourceSingleton4(); // 加上synchronized ()，问题仍没有解决
                }
            }
            return dataSource;
    }
}

以上存在线程安全问题。

④ 线程安全改进版⼆

单例模式--懒汉模式4 线程安全改进版⼆
public class DataSourceSingleton5 {
    // 1. 私有的构造方法
    private DataSourceSingleton5() {
    }
    // 2. 私有的属性
    private static DataSourceSingleton5 dataSource = null;

    // 3. 公共的访问方法，得到单例对象
    public static DataSourceSingleton5 getInstance() {
        //在返回dataSourse的之前，要先判断，是不是第一次访问，如果是第一次访问，需要new一个对象,此时，存在线程安全问题
        // 加上synchronized ()，问题仍没有解决
        //在synchronized ()内部再次判断是不是第一次访问
        if(dataSource == null) { // 大致分流状态
            synchronized (DataSourceSingleton4.class) {
                if(dataSource == null) { // 精细化的分流（DCL双重效验锁）
                    dataSource = new DataSourceSingleton5();
                }
            }
        }
        return dataSource;
    }
}

以上存在线程安全问题，对象创建需要三步：

1. 给对象分配内存

2. 初始化对象

3. 设置对象到相应的内存地址上

假如因为指令重排导致执⾏的顺序变为了132，那么假如a线程中执⾏完1、3之后,b线程到达代码2处.执⾏判断语句，发现instance指向的是⼀段地址，因此直接不进⼊判断语句⽽是直接返回了⼀个没有初始化的空的对象。

⑤ 线程安全改进最终版

单例模式--懒汉模式5 线程安全改进最终版
public class DataSourceSingleton6 {
    // 1. 私有的构造方法
    private DataSourceSingleton6() {

    }
    // 2. 私有的属性
    private static volatile DataSourceSingleton6 dataSource = null;

    // 3. 公共的访问方法，得到单例对象
    public static DataSourceSingleton6 getInstance() {
        //在返回dataSourse的之前，要先判断，是不是第一次访问，如果是第一次访问，需要new一个对象,此时，存在线程安全问题
        // 加上synchronized ()，问题仍没有解决
        //在synchronized ()内部再次判断是不是第一次访问
        if(dataSource == null) { // 大致分流状态
            synchronized (DataSourceSingleton4.class) {
                if(dataSource == null) { // 精细化的分流（DCL双重效验锁）
                    dataSource = new DataSourceSingleton6();
                }
            }
        }
        return dataSource;
    }
}