十一 设计模式--单例模式

最新推荐文章于 2026-01-08 23:44:03 发布
原创 最新推荐文章于 2026-01-08 23:44:03 发布 · 144 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式 #java #程序人生

本文深入解析单例设计模式，涵盖八种实现方式，包括饿汉式、懒汉式、双重检查、静态内部类和枚举等，探讨每种方式的优缺点及适用场景。

文章目录

1 单例设计模式介绍

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。
比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够，这是就会使用到单例模式。

2 单例设计模式八种方式

单例模式有八种方式：

  • 饿汉式(静态常量)
  • 饿汉式（静态代码块）
  • 懒汉式(线程不安全)
  • 懒汉式(线程安全，同步方法)
  • 懒汉式(线程安全，同步代码块)
  • 双重检查
  • 静态内部类
  • 枚举

3 饿汉式（静态常量）

饿汉式（静态常量）应用实例
步骤如下：

  1. 构造器私有化 (防止 new )
  2. 类的内部创建对象
  3. 向外暴露一个静态的公共方法。getInstance

3.1 代码实现

package com.andy.singleton.type01;

public class SingleTonTest01 {
    public static void main(String[] args) {

        //测试,创建的类是否是同一个对象
        SingleTon01 instance = SingleTon01.getInstance();
        SingleTon01 instance1 = SingleTon01.getInstance();

        System.out.println(instance == instance1);

        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

class SingleTon01 {
    //1. 构造器私有化
    private SingleTon01() {
    }

    //2. 提供静态变量,并且在类中创建对象
    private static SingleTon01 singleTon01 = new SingleTon01();

    //3. 提供静态方法获取该对象实例
    public static SingleTon01 getInstance() {
        return singleTon01;
    }
}

输出结果:

true
460141958
460141958

结果说明创建的对象是同一个.

3.2 优缺点说明

  1. 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
  2. 缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
  3. 这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果
  4. 结论：这种单例模式可用，可能造成内存浪费

4 饿汉式（静态代码块)

4.1 代码演示

package com.andy.singleton.type02;

public class SingleTonTest02 {
    public static void main(String[] args) {

        //测试,创建的类是否是同一个对象
        SingleTon01 instance = SingleTon01.getInstance();
        SingleTon01 instance1 = SingleTon01.getInstance();

        System.out.println(instance == instance1);

        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

class SingleTon01 {
    //1. 构造器私有化
    private SingleTon01() {
    }

    //2. 提供静态变量,并且在类中创建对象
    private static SingleTon01 singleTon01;

    static {
        singleTon01 = new SingleTon01();
    }

    //3. 提供静态方法获取该对象实例
    public static SingleTon01 getInstance() {
        return singleTon01;
    }
}

输出结果:

true
460141958
460141958

4.2 优缺点说明

  1. 这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
  2. 结论：这种单例模式可用，但是可能造成内存浪费

5 懒汉式(线程不安全)

5.1 代码演示

package com.andy.singleton.type03;

public class SingleTonTest03 {
    public static void main(String[] args) {

        //测试,创建的类是否是同一个对象
        SingleTon01 instance = SingleTon01.getInstance();
        SingleTon01 instance1 = SingleTon01.getInstance();

        System.out.println(instance == instance1);

        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

class SingleTon01 {
    //1. 构造器私有化
    private SingleTon01() {
    }

    //2. 提供静态变量
    private static SingleTon01 singleTon01;

    //3. 提供静态方法获取该对象实例,判断如果静态变量为null,创建对象
    // 目的是在第一次条用该函数时创建对象
    public static SingleTon01 getInstance() {
        if(singleTon01 == null){
            singleTon01 = new SingleTon01();
        }
        return singleTon01;
    }
}

5.2 优缺点说明

  1. 起到了Lazy Loading的效果，但是只能在单线程下使用。
  2. 如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行(场景分析:就是来不及new一个对象,这时候singleton 为null,这时候该线程挂住,让个下一线程执行)，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式.
  3. 结论：在实际开发中，不要使用这种方式.

6 懒汉式(线程安全，同步方法)

6.1 代码演示

package com.andy.singleton.type04;

public class SingleTonTest04 {
    public static void main(String[] args) {

        //测试,创建的类是否是同一个对象
        SingleTon01 instance = SingleTon01.getInstance();
        SingleTon01 instance1 = SingleTon01.getInstance();

        System.out.println(instance == instance1);

        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

class SingleTon01 {
    //1. 构造器私有化
    private SingleTon01() {
    }

    //2. 提供静态变量
    private static SingleTon01 singleTon01;

    //3. 提供静态方法获取该对象实例并让该方法进行进程同步,判断如果静态变量为null,创建对象
    // 目的是在第一次条用该函数时创建对象,
    public static synchronized SingleTon01 getInstance() {
        if(singleTon01 == null){
            singleTon01 = new SingleTon01();
        }
        return singleTon01;
    }
}

6.2 优缺点说明

  1. 解决了线程不安全问题
  2. 效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低.
  3. 结论：在实际开发中，不推荐使用这种方式

7 懒汉式(线程安全，同步代码块)应用实例

7.1 代码演示

package com.andy.singleton.type05;

public class SingleTonTest05 {
    public static void main(String[] args) {

        //测试,创建的类是否是同一个对象
        SingleTon01 instance = SingleTon01.getInstance();
        SingleTon01 instance1 = SingleTon01.getInstance();

        System.out.println(instance == instance1);

        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

class SingleTon01 {
    //1. 构造器私有化
    private SingleTon01() {
    }

    //2. 提供静态变量
    private static SingleTon01 singleTon01;

    //3. 提供静态方法获取该对象实例并让该方法进行进程同步,判断如果静态变量为null,创建对象
    // 目的是在第一次条用该函数时创建对象,
    public static synchronized SingleTon01 getInstance() {
        if(singleTon01 == null){
            synchronized (SingleTon01.class){
                singleTon01 = new SingleTon01();
            }
            
        }
        return singleTon01;
    }
}

7.2 优缺点说明

  1. 这种方式，本意是想对第四种实现方式的改进，因为前面同步方法效率太低，改为同步产生实例化的的代码块
  2. 但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致，假如一个线程进入了if (singleton ==null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例
  3. 结论：在实际开发中，不能使用这种方式

8 双重检查

8.1 代码演示

package com.andy.singleton.type06;

public class SingleTonTest06 {
    public static void main(String[] args) {

        //测试,创建的类是否是同一个对象
        SingleTon01 instance = SingleTon01.getInstance();
        SingleTon01 instance1 = SingleTon01.getInstance();

        System.out.println(instance == instance1);

        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

class SingleTon01 {
    //1. 构造器私有化
    private SingleTon01() {
    }

    //2. 提供静态变量
    private static volatile SingleTon01 singleTon01;

    //3. 提供静态方法获取该对象实例并让该方法进行进程同步,判断如果静态变量为null,创建对象
    // 目的是在第一次条用该函数时创建对象,
    public static synchronized SingleTon01 getInstance() {
        if(singleTon01 == null){
            synchronized (SingleTon01.class){
                if (singleTon01 == null) {
                    singleTon01 = new SingleTon01();
                }
            }

        }
        return singleTon01;
    }
}

8.2 优缺点说明

  1. Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。
  2. 这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象，也避免的反复进行方法同步.
  3. 线程安全；延迟加载；效率较高
  4. 结论：在实际开发中，推荐使用这种单例设计模式

9 静态内部类

9.1 代码演示

package com.andy.singleton.type07;

public class SingleTonTest07 {
    public static void main(String[] args) {

        //测试,创建的类是否是同一个对象
        SingleTon01 instance = SingleTon01.getInstance();
        SingleTon01 instance1 = SingleTon01.getInstance();

        System.out.println(instance == instance1);

        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

class SingleTon01 {
    //1. 构造器私有化
    private SingleTon01() {
    }

    private static class SingleTonInstance{
        private static final SingleTon01 SINGLE = new SingleTon01();
    } 
    
    public static synchronized SingleTon01 getInstance() {
        
        return SingleTonInstance.SINGLE;
    }
}

9.2 优缺点说明

  1. 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
  2. 静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
  3. 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
  4. 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
  5. 结论：推荐使用.

10 枚举

10.1 代码演示

package com.andy.singleton.type008;

public enum SingleTon {
    INSTANCE;
    public void method(){
        
    }
    
}

10.2 优缺点说明

  1. 这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
  2. 这种方式是Effective Java作者Josh Bloch 提倡的方式
  3. 结论：推荐使用

11 单例模式在JDK 应用的源码分析

  1. 我们JDK中，java.lang.Runtime就是经典的单例模式(饿汉式)
  2. 代码分析+Debug源码+代码说明
    在这里插入图片描述

12 单例模式注意事项和细节说明

  1. 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
  2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new
  3. 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)
嵌入式C语言设计模式 --- 单例模式
EmbedIoT Studio
12-29 2640
单例模式（Singleton Pattern）是软件程序设计中最简单的设计模式之一，单例模式在设计模式分类中，是属于创建型模式，它提供了一种创建对象（实例，变量）的最佳实践方式。顾名思义，单例（也叫单件），也就是在整个程序设计中，只存在一个单一的类（C语言中叫“类型”，通常用结构体类型表示），这个类负责创建一个对象（C语言中叫“定义变量”，通常是指结构体变量）
设计模式-单例模式-注册式单例模式-枚举式单例模式和容器式单例模式在Java中的使用示例
BADAO_LIUMANG_QIZHI的博客
10-28 1280
上面讲了单例模式的三种方式，另外还有一种注册式单例模式。
C#设计模式--单例模式
weixin_53545579的博客
04-29 1188
普通单例：一进门就把所有家具都准备好（程序启动时就创建实例）懒加载单例：等你要用沙发时才去买沙发（第一次访问时才创建实例）
设计模式-单例模式
HL_LOVE_C的博客
01-03 1796
单例模式是一种设计模式，它。就像是在一个软件系统中，某些资源或者对象只需要存在一个就可以满足系统的需求，比如系统的配置管理器、数据库连接池等。通过单例模式，可以避免创建多个实例导致的资源浪费、数据不一致等问题。
JAVA设计模式--单例模式
JAVA_SR的博客
09-21 938
单例设计模式
JavaScript设计模式 -- 单例模式
u014676858的博客
02-11 1221
单例模式的核心思想是保证一个类只有一个实例存在，并提供一个全局访问点来获取该实例。这样可以防止重复创建对象，节省资源，同时也便于全局共享数据或状态。单例模式的特点：唯一性：在系统中只有一个实例存在。全局访问：提供一个全局访问点，让其他对象能够轻松地获取这个实例。延迟实例化：通常采用懒加载方式，只有在第一次使用时才创建实例。单例模式是一种简单但十分有用的设计模式，通过确保全局唯一实例，可以为配置管理、日志记录、事件总线、数据库连接等场景提供一致的解决方案。
C++设计模式---单例模式
专注
06-08 1410
由于是在编译时确定的初始化，因此这种方式是线程安全的（在C++11及以后的版本中），并且不需要额外的同步机制。然而，在大多数情况下，这些缺点都是可以接受的，因为单例对象通常代表一些重要的系统资源或功能，需要尽早地初始化。通过单例模式可以创建一个缓存管理器，确保只有一个缓存实例存在，并且可以被多个线程共享，方便全局访问和统一管理缓存。当需要对资源进行集中管理，以确保线程安全的访问时，单例模式是一个不错的选择。当实例化一个类的成本较高，而且只需要一个实例时，可以使用单例模式来避免重复实例化的开销。
设计模式-单例模式（Singleton Pattern）
weixin_60653563的博客
08-22 1846
单例模式。饿汉式单例；懒汉式；枚举式单例；容器式单例；ThreadLocal式单例。
设计模式-单例模式（Singleton）
miaoyl的博客
11-03 2287
Java 单例模式（Singleton）是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点。这种模式通常用于需要频繁创建和销毁的对象，例如数据库连接、线程池等。
Android 设计模式--单例模式
袁震的博客
11-11 1419
单例模式优点：1，单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁的创建，销毁时，单例模式的优势就非常明显了2，由于单例模式只生成一个实例，所以，减少了系统的性能开销，当一个对象的创建需要比较多的资源时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决。缺点：1，单例模式一般没有接口，扩展很难2，单例对象如果持有context，很容易发生内存泄漏，此时需要注意，传递给单例对象的Context最好是Application Context。
C++：设计模式-单例模式
己亥谷雨
11-22 2357
通过方法获取单例实例，这是调用饿汉式单例的标准方式。由于饿汉式实例在程序启动时就被创建，所以你不需要显式地进行实例化操作。饿汉式：简单，适合不需要延迟初始化的场景，程序启动时就创建实例。懒汉式：适合需要延迟初始化的场景，但需要考虑线程安全。线程安全懒汉式：通过加锁保证线程安全，但可能带来性能开销。双重检查锁：线程安全，减少了加锁的频率，但实现复杂。静态局部变量：线程安全，简洁，现代 C++ 中推荐的单例实现方式。在现代 C++ 中，静态局部变量。
通过C++实现一个设计模式-单例模式.zip
02-18
单例模式（Singleton Pattern）是软件设计中的一种常用设计模式，它确保一个类只有一个实例，并且提供一个全局访问点。单例模式属于创建型模式，它在Java、C++、Python等多种编程语言中都有广泛的应用。单例模式的...
JAVA-设计模式-创建型模式-单例模式
08-10
JAVA-设计模式-创建型模式-单例模式
MyBatis设计模式之装饰器、模版方法、策略模式
qq_41262225的博客
01-05 910
MyBatis框架中巧妙运用了多种设计模式来提升架构灵活性和扩展性。本文重点分析了装饰器模式、模板方法模式和策略模式的应用：装饰器模式通过CachingExecutor和Cache装饰器链动态添加功能而不修改原有结构；模板方法模式在BaseExecutor和BaseTypeHandler中实现算法骨架；策略模式则通过RoutingStatementHandler灵活切换执行策略。这些模式的应用使MyBatis在保持核心稳定的同时，能够灵活应对各种扩展需求，体现了优秀框架的设计智慧。
HarmonyOS 多页面架构设计模式总结
guanmingyuangmy的博客
01-04 863
页面只负责 UI，路由统一管理，状态集中托管，逻辑模块化拆分HarmonyOS 的多页面架构并不复杂，难点不在 API，而在工程设计意识。如果你：正在从 Android 转 HarmonyOS或正在做一个中大型鸿蒙项目那么尽早建立清晰的多页面架构，会极大降低后期维护成本。
设计模式之享元模式
sxlishaobin的博客
01-07 929
享元模式(FlyWeight)，属于结构型设计模式，主要解决实例化大量相同的对象，从而导致可能的内存泄漏的问题。为了解决这个问题，享元模式提出的解决办法是将相同的对象保存在内存中，且仅保存一个对象，因此该对象应该是不可被修改的，当需要获取该对象实例时，直接从内存中读取即可，从而避免了相同对象的重复创建。下面是享元模式的定义：运用共享技术有效地支持大量细粒度的对象总之，享元模式适用于那些需要大量使用相同或相似对象，并且需要频繁创建和销毁同一类对象的场景。
二十三种设计模式(二十三)--责任链模式
最新发布
万波的技术博客
01-08 247
摘要：责任链模式用于处理同一请求的多级响应场景。通过军队作战案例展示：团、旅、师、军四级单位按敌军规模依次迎战。每个单位处理能力范围内任务，超出则转交上级。代码实现抽象基类MilUnit和具体子类，通过setNext()建立责任链。调用时从链首（团级）触发，自动路由到合适处理者。该模式适用于多级审批等类似场景，需注意封装链首防止调用混乱。典型应用包括请假审批等分级处理系统。
设计模式之装饰器模式
sxlishaobin的博客
01-07 958
装饰器模式(Decoration Pattern)，属于结构型设计模式，用于在不改变现有对象的基础上，对该对象的方法动态地添加新的功能，实现对该对象原有方法的增强装饰器模式的设计思想是将对象的核心功能和附加功能独立开来。核心功能由现有对象提供，附加功能由装饰器提供。装饰器的实现思路是存在一个抽象的装饰器类，该装饰器类用于对现有的对象进行包装，然后通过该装饰器的具体子类对包装的类的方法进行增强。推而论之，在存在多个装饰器具体子类的情况下，可以动态地。
设计模式之工厂模式
sxlishaobin的博客
01-05 792
工厂模式(Factory Pattern)是最常使用的设计模式之一，属于创建型设计模式。在该设计模式中，我们不再使用new来实例化对象，而是通过工厂对象来获取指定的对象实例，其中对象的实例化过程是在工厂中完成的。换句话说，就是将对象的实例化过程从调用方控制改变成工厂控制。
C#实现的23种设计模式-单例模式解析
"该文档是关于23种经典设计模式的C#版本介绍，主要讨论了其中的一种——单例模式（Singleton Pattern）。" 在软件工程中，设计模式是一种被广泛接受并反复使用的解决方案模板，用于解决常见的设计问题。单例模式是...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值