java设计模式----单例设计模式

关注

原创最新推荐文章于 2026-04-16 09:25:39 发布 461 阅读 AI 写同款· GEO 优化 ›

Java设计模式之单例设计模式 初步认识设计模式、23种设计模式简介下载、单例模式的初步认识、单例模式的饿汉式和懒汉式的实现阅读详情

主文章（所有java设计模式的目录）
https://blog.youkuaiyun.com/grd_java/article/details/122252696

源码位置
码云：https://gitee.com/yin_zhipeng/design_mode.git
GitHub：

学习设计模式前必须知道的东西

看待设计模式，要站在更大的角度（代码重用性、可读性、可扩展性、可靠性、程序高内聚，低耦合）来综合考虑看待，而不是功能实现的角度看待，不要觉得实现一个功能没必要这么麻烦

文章中给出的设计模式类图都是标准的实现方式，并不一定要完全遵守标准，所以只要设计思想符合，一个设计模式有多种实现方式，尤其是看别人源码的时候，不要用标准类图死扣

文章目录

1. 单例设计模式

单例设计模式

采取一定方法，保证整个软件系统运行中，只存在一个对象实例，且该类只提供一个取得其对象实例的方法
例如Hibernate的SessionFactory，它充当数据存储源的代理，负责创建Session对象，它不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够了，这时就需要单例模式

下面介绍8中单例模式，实际开发可以的如下

饿汉式单例模式，如果你保证项目中必然会用到这个实例，就可以用，否则会资源浪费
懒汉式—双重检查版，如果项目中不一定用到这个实例，为了避免资源浪费，可以用懒汉式，但是多线程高并发场景下，需要双重检查保证线程安全
静态内部类实现单例，根据JVM底层运行原理实现
枚举类实现单例，好用，推荐

1. 饿汉式单例

类被加载，就实例化了实例，一直等着被使用，所以叫饿汉式

优点

写法简单，类加载时就完成实例化，避免线程同步问题

缺点

类加载时就完成实例化，没有达到懒加载（Lazy Loading）效果，如果从始至终从未使用过这个实例，则会造成内存浪费
基于classloder（类加载）机制，避免了多线程同步问题，但是，instance（实例）在类加载时就实例化。在单例模式中，大多调用getInstance方法，触发类加载，但是如果有其它静态方法等一系列东西导致类加载，此时虽然我们不想使用这个单例，内存中也初始化了它。
这种单例模式可用，但是可能造成内存浪费

1. 静态常量版本

步骤：代码在com.yzpnb.design_mode.singleton.hungry_singleton包下StaticConstSingleton类

构造器私有化(保证外部不可以new对象)
类的内部创建自己的实例对象（外部不能new，那就自己new）
向外暴露一个静态公共方法(外部只能通过这个方法，获取我们自己new的那一个对象)

/**
 * 饿汉式单例设计模式------静态常量版
 */
public class StaticConstSingleton {
    public static void main(String[] args) {
        //获取到单例实例，一个类，整个项目运行时，只有一个类对象，所以获取到的实例都会是同一个
        StaticConstSingleton singleton = StaticConstSingleton.getSingleton();
        StaticConstSingleton singleton2 = StaticConstSingleton.getSingleton();
        System.out.println("两个实例是否相同"+(singleton2 == singleton));//结果为true.两个实例对象是同一个
        System.out.println("两个实例hashCode值分别是多少："+singleton2.hashCode()+"==========="+singleton.hashCode());
    }

    //1、私有化构造方法
    private StaticConstSingleton(){

    }
    //2. 自己将实例new出来
    private static final StaticConstSingleton singleton = new StaticConstSingleton();

    //3. 提供公共方法，获取我们自己new出来的实例
    public static StaticConstSingleton getSingleton(){
        return singleton;
    }
}

2. 静态代码块版本

步骤：代码在com.yzpnb.design_mode.singleton.hungry_singleton包下StaticCodeBlock类

构造器私有化(保证外部不可以new对象)
类的内部创建自己的实例对象（外部不能new，那就自己new）
向外暴露一个静态公共方法(外部只能通过这个方法，获取我们自己new的那一个对象)

/**
 * 饿汉式单例设计模式------静态代码块版
 */
public class StaticCodeBlock {
    public static void main(String[] args) {
        //获取到单例实例，一个类，整个项目运行时，只有一个类对象，所以获取到的实例都会是同一个
        StaticCodeBlock singleton = StaticCodeBlock.getInstance();
        StaticCodeBlock singleton2 = StaticCodeBlock.getInstance();
        System.out.println("两个实例是否相同"+(singleton2 == singleton));//结果为true.两个实例对象是同一个
        System.out.println("两个实例hashCode值分别是多少："+singleton2.hashCode()+"==========="+singleton.hashCode());
    }
    //1.私有化构造
    private StaticCodeBlock(){}
    //2.自己定义单例
    private static StaticCodeBlock staticCodeBlock ;
    //3.静态代码块搞出来实例
    static{
        staticCodeBlock = new StaticCodeBlock();
    }
    //4.提供方法
    public static StaticCodeBlock getInstance(){
        return staticCodeBlock;
    }
}

2. 懒汉式

懒加载机制，不浪费内存，调用getInstance方法才会new实例
但是多线程下需要解决线程安全和同步问题

以下3种懒汉式都是`多线程情况下有问题`的，面试官常问，大家最好看看，`了解`下面3种实现方式`有哪些问题`，如果`不想看`，`直接看正确的双重检查版`

1. 线程不安全

步骤：代码在com.yzpnb.design_mode.singleton.idler_singleton包下ThredUnsafetySingleton类

私有化构造函数
自己创静态实例，但不初始化
提供公共静态方法获取实例，并在这里初始化单例

此方法在多线程场景下，会出现如下问题，所以实际开发多线程程序不要使用这种方式

当第一个线程进入getInstace中，判断singleton为null，则创建单例
此时单例初始化未完成，又一个线程进入，发现singleton没有值，又进行一次初始化。出现多次初始化的问题。
又一个线程进入，发现有值，不为null，所以直接拿走实例
此时，这个线程拿了一个没有初始化完成的实例对象走了，程序出错

/**
 * 懒汉式单例
 * 线程不安全版
 */
public class ThredUnsafetySingleton {
    public static void main(String[] args) {
        ThredUnsafetySingleton singleton = ThredUnsafetySingleton.getInstance();
        ThredUnsafetySingleton singleton2 = ThredUnsafetySingleton.getInstance();
        System.out.println("两个实例是否相同"+(singleton2 == singleton));
    }
    //1. 私有化构造函数
    private ThredUnsafetySingleton(){}
    //2. 自己创静态实例，但不初始化
    private static ThredUnsafetySingleton singleton;
    //3. 提供公共静态方法获取实例，并在这里初始化单例
    public static ThredUnsafetySingleton getInstance(){
        if(singleton == null){
            singleton = new ThredUnsafetySingleton();
        }
        return singleton;
    }
}

2. 线程安全，同步方法

步骤：代码在com.yzpnb.design_mode.singleton.idler_singleton包下ThreadSafetySingleton类

在线程不安全的懒汉式版本基础上，为getInstance方法添加synchronize关键字

会出现如下问题，所以实际开发多线程程序不要使用这种方式

虽然解决了线程不安全问题
但是效率太低，每个线程想要获取类实例时，执行getInstance()方法都要进行同步，但是实例化代码只需要执行一次就够了，后面想获得该实例，直接return即可，但是现在连return都需要同步

/**
 * 懒汉式单例
 * 线程安全版，对方法进行同步
 */
public class ThreadSafetySingleton {
    public static void main(String[] args) {
        ThredUnsafetySingleton singleton = ThredUnsafetySingleton.getInstance();
        ThredUnsafetySingleton singleton2 = ThredUnsafetySingleton.getInstance();
        System.out.println("两个实例是否相同"+(singleton2 == singleton));
    }
    //1. 私有化构造方法
    private ThreadSafetySingleton(){}
    //2. 创建static实例
    private static ThreadSafetySingleton singleton;
    //3. 提供公共静态方法获取实例，并在这里初始化单例，并加入synchronize关键字修饰代码块
    public static synchronized ThreadSafetySingleton getInstance(){
        if(singleton == null){
            singleton = new ThreadSafetySingleton();
        }
        return singleton;
    }
}

3. 线程安全，同步代码块

步骤：代码在com.yzpnb.design_mode.singleton.idler_singleton包下ThreadSafetySynchroniztionCodeBlockSingleton类

在线程不安全的懒汉式版本基础上，为getInstance方法中实例化单例的代码添加synchronize关键字

会出现如下问题，所以实际开发多线程程序不要使用这种方式

虽然解决了效率问题，线程直接return对象时，不需要实例化单例。但是线程不安全问题重新出现了
当一个线程进行初始化，此时其它线程判断null进来发现代码加锁，等第一个线程走了，他还是会去执行初始化代码
依然会有线程拿一个默认值走的情况发生

/**
 * 懒汉式单例
 * 线程安全版，对代码块进行同步
 */
public class ThreadSafetySynchroniztionCodeBlockSingleton {
    //1. 私有化构造
    private ThreadSafetySynchroniztionCodeBlockSingleton(){}
    //2. 创建静态实例
    private static ThreadSafetySynchroniztionCodeBlockSingleton singleton;
    //3. 提供公共方法获取单例,只对实例化单例时的操作加锁做同步
    public static ThreadSafetySynchroniztionCodeBlockSingleton getInstance(){
        if(singleton == null){
            synchronized (ThreadSafetySynchroniztionCodeBlockSingleton.class){
                singleton = new ThreadSafetySynchroniztionCodeBlockSingleton();
            }
        }
        return singleton;
    }
}

4. 双重检查(重点)

步骤：代码在com.yzpnb.design_mode.singleton.idler_singleton包下DoubleCheck类

在线程安全，同步代码块的基础上，synchronized代码块中，也加上判断

解决上面三种懒汉式的问题，推荐使用

解决线程安全问题
效率比直接同步方法高,只有初始化时需要同步，获取实例时，不需要同步
当多个线程判断实例为null，进入if执行初始化，因为初始化代码加锁，只有一个能进去
此时，加锁代码中，再次判断是否为null，如果是null执行初始化。第一个线程进去会执行初始化，初始化完成，释放锁，第二个线程进去再次判断，发现不为null，不执行初始化

/**
 * 懒汉式单例
 * 线程安全，双重检查
 */
public class DoubleCheck {
    //1. 私有化构造
    private DoubleCheck(){}
    //2. 创建静态实例
    private static DoubleCheck singleton;
    //3. 提供公共方法获取单例,只对实例化单例时的操作加锁做同步
    public static DoubleCheck getInstance(){
        if(singleton == null){
            //假设多个线程同时判断null进来初始化，此时这里只能进入一个线程初始化
            synchronized (DoubleCheck.class){
                if(singleton == null){//双重检查，第一个线程初始化完成，其它线程再进来，singleton就不是null了，不会重复初始化
                    singleton = new DoubleCheck();
                }
            }
        }
        return singleton;
    }
}

3. 静态内部类

外部类被加载时，静态内部类不会被装载
当我们使用静态内部类中静态变量或常量时，会加载内部类
类加载时，是线程安全的（JVM帮我们保证线程安全，类初始化时，其它线程无法进入）

基于以上3点，我们可以实现一种单例,步骤如下：代码在com.yzpnb.design_mode.singleton.inner_class_singleton包下InnerClassSingleton类

私有构造
静态内部类，创建实例
提供公共方法获取单例对象(使用静态内部类变量)

/**
 * 静态内部类创建单例
 * 线程安全，效率高
 * 代码简洁
 * > 1. 外部类被加载时，静态内部类不会被装载
 * > 2. 当我们使用静态内部类中静态变量或常量时，会加载内部类
 * > 3. 类加载时，是线程安全的
 */
public class InnerClassSingleton {
    //1. 私有构造
    private InnerClassSingleton(){}
    //2. 静态内部类，创建实例
    private static class SingletonInstance{
        private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
    }
    //3. 提供公共方法获取单例对象
    public static InnerClassSingleton getInstance(){
        return SingletonInstance.INSTANCE;//使用静态内部类变量时，会加载内部类
    }
}

4. 枚举

借助JDK1.5中加入的枚举来实现单例模式，不仅可以避免多线程同步问题，还能防止反序列化重新创建新对象
是Effective Java作者Josh Bloch提倡的方式

步骤如下：代码在com.yzpnb.design_mode.singleton.emnu_singleton包下EmnuSingleton类

创建枚举
声明属性
用就完事了

/**
 * 使用枚举，实现单例
 */
public class EmnuSingleton {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        instance.say();
    }
}
enum Singleton{
    INSTANCE;//属性
    public void say(){
        System.out.println("SAY---");
    }
}