设计模式--单例模式

最新推荐文章于 2025-12-29 10:26:33 发布
原创 最新推荐文章于 2025-12-29 10:26:33 发布 · 198 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式 #单例模式

本文深入解析单例模式的八种实现方式，包括饿汉式、懒汉式、双重检查、静态内部类和枚举等，探讨每种方式的优缺点，帮助理解单例模式在不同场景下的应用。

简介：单例模式就是采取一定的方法，保证在整个软件系统中，对某个类只存在一个实例对象，并且该类只提供一个静态的获取其对象实例的方法；

 

单例模式有8种方式：

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

-----------------------------------------------------分  割  线--------------------------------------------------------

  • 1. 饿汉式（静态常量）
class Singleton {

    // 1.私有化构造器
    private Singleton() {

    }


    // 2.本类内部创建实例
    private final static Singleton singleton = new Singleton();



    // 3.提供一个公开的静态的获取实例的方法
    public static Singleton getSingleton() {
        return singleton;
    }

}



/**
 * 单例模式-饿汉式（静态常量）
 * 优缺点说明：
 * 1.优点：写法比较简单，在类转载时实例化对象，避免了线程同步问题。
 * 2.缺点：在类装载时完成实例化，没有Lazy Loading的效果，如果从始至终
 * 没有实例化这个类，将会造成线程浪费；
 * @param args
 */
public static void main(String[] args) {
    Singleton singleton1 = Singleton.getSingleton();
    Singleton singleton2 = Singleton.getSingleton();
    System.out.println(singleton1==singleton2); //true
    System.out.println(singleton1.hashCode()); //366712642
    System.out.println(singleton2.hashCode()); //366712642
}

-----------------------------------------------------分  割  线--------------------------------------------------------

  • 2.饿汉式（静态代码块）
class Singleton2 {

    // 1.私有化构造器
    private Singleton2() {

    }


    // 2.本类内部创建实例
    private static Singleton2 singleton;


    // 3.静态代码块中创建实例对象
    static {
        singleton = new Singleton2();
    }


    // 3.提供一个公开的静态的获取实例的方法
    public static Singleton2 getSingleton() {
        return singleton;
    }

}


/**
 * 饿汉式（静态代码块）
 * 优缺点说明：
 * 1.优点：写法比较简单，在静态代码块中实例化对象，避免了线程同步问题。
 * 2.缺点：在类装载时完成实例化，没有Lazy Loading的效果，如果从始至终
 * 没有实例化这个类，将会造成线程浪费；
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Singleton2 singleton1 = Singleton2.getSingleton();
    Singleton2 singleton2 = Singleton2.getSingleton();
    System.out.println(singleton1 == singleton2); // true
    System.out.println(singleton1.hashCode()); // 366712642
    System.out.println(singleton2.hashCode()); // 366712642
}

-----------------------------------------------------分  割  线--------------------------------------------------------

  • 3.懒汉式（线程不安全）
class Singleton3 {

    // 1.私有化构造器
    private Singleton3() {

    }


    // 2.本类内部创建实例
    private static Singleton3 singleton;


    // 3.提供一个公开的静态的获取实例的方法
    public static Singleton3 getSingleton() {
        if (singleton == null) {
            singleton = new Singleton3();
        }
        return singleton;
    }
}



/**
 * 懒汉式（线程不安全） 优缺点说明：
 * 1. 起到了Lazy Loading的效果，但是只能在单线程中使用
 * 2. 如果在多线程下，if (singleton == null) 判断语句块，还未来的及往下执行，另一个线程也通过了这个判断
 * 这时便会出现多个实例，所以在多线程的情况下，不推荐使用这种方式；
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Singleton3 singleton1 = Singleton3.getSingleton();
    Singleton3 singleton2 = Singleton3.getSingleton();
    System.out.println(singleton1 == singleton2); // true
    System.out.println(singleton1.hashCode()); // 366712642
    System.out.println(singleton2.hashCode()); // 366712642
}

-----------------------------------------------------分  割  线--------------------------------------------------------

 

  • 4.懒汉式（线程安全，同步方法）
class Singleton4 {

    // 1.私有化构造器
    private Singleton4() {

    }


    // 2.本类内部创建实例
    private static Singleton4 singleton;


    // 3.提供一个公开的静态的获取实例的方法
    public static synchronized Singleton4 getSingleton() {
        if (singleton == null) {
            singleton = new Singleton4();
        }
        return singleton;
    }
}



/**
 * 懒汉式（线程安全，同步方法） 优缺点说明：
 * 1. 解决了线程安全的问题
 * 2. 同步代码块的效率太低了
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Singleton4 singleton1 = Singleton4.getSingleton();
    Singleton4 singleton2 = Singleton4.getSingleton();
    System.out.println(singleton1 == singleton2); // true
    System.out.println(singleton1.hashCode()); // 366712642
    System.out.println(singleton2.hashCode()); // 366712642
}

-----------------------------------------------------分  割  线--------------------------------------------------------

 

  • 5.懒汉式（线程安全，同步方法块）
class Singleton5 {

    // 1.私有化构造器
    private Singleton5() {

    }


    // 2.本类内部创建实例
    private static Singleton5 singleton;


    // 3.提供一个公开的静态的获取实例的方法
    public static Singleton5 getSingleton() {
        if (singleton == null) {
            synchronized(Singleton5.class){
                singleton = new Singleton5();
            }
        }
        return singleton;
    }
}



/**
 * 懒汉式（线程安全，同步方法块）  
 * 1. 解决了线程安全的问题
 * 2. 同步代码块的效率太低了
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Singleton5 singleton1 = Singleton5.getSingleton();
    Singleton5 singleton2 = Singleton5.getSingleton();
    System.out.println(singleton1 == singleton2); // true
    System.out.println(singleton1.hashCode()); // 366712642
    System.out.println(singleton2.hashCode()); // 366712642
}

-----------------------------------------------------分  割  线--------------------------------------------------------

 

  • 6.双重检查

class Singleton6 {

    // 1.私有化构造器
    private Singleton6() {

    }

    // 2.本类内部创建实例
    private static volatile Singleton6 singleton;

    // 3.提供一个公开的静态的获取实例的方法
    public static Singleton6 getSingleton() {
        if (singleton == null) {
            synchronized(Singleton6.class){
                if (singleton == null) {
                    singleton = new Singleton6();
                }
            }
        }
        return singleton;
    }
}



/**
  * 双重检查
  * 1. 线程安全，延迟加载，效率高
  * 2. 推荐使用这种单例模式
  * @param args
  */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Singleton6 singleton1 = Singleton6.getSingleton();
    Singleton6 singleton2 = Singleton6.getSingleton();
    System.out.println(singleton1 == singleton2); // true
    System.out.println(singleton1.hashCode()); // 366712642
    System.out.println(singleton2.hashCode()); // 366712642
}

-----------------------------------------------------分  割  线--------------------------------------------------------

 

  • 7.静态内部类
class Singleton7 {

    // 1.私有化构造器
    private Singleton7() {

    }

    // 2.静态内部类创建对象
    private static class SingletonInstance {
        private static final Singleton7 INSTANCE = new Singleton7();
    }


    // 3.提供一个公开的静态的获取实例的方法
    public static Singleton7 getSingleton() {
        return SingletonInstance.INSTANCE;
    }
}



/**
 * 静态内部类
 * 优缺点： 1.这种方式采用类加载的机制来保证初始化实例时只有一个线程 2.静态内部类方式在 Singleton7
 * 类被装载时，不会立即初始化，而是需要在实例化时，调用 getSingleton 才会调用 SingletonInstance
 * 方法，从而完成初始化；
 * 3.类的静态方法只会在类的第一次加载时初始化，所以在这里，JVM机制帮我们保证了线程的安全性，在类进行初始化时，别的线程无法进入；
 * 4.优点：为了避免线程不安全，利用静态内部类特点实现延迟加载，效率高；
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Singleton7 singleton1 = Singleton7.getSingleton();
    Singleton7 singleton2 = Singleton7.getSingleton();
    System.out.println(singleton1 == singleton2); // true
    System.out.println(singleton1.hashCode()); // 366712642
    System.out.println(singleton2.hashCode()); // 366712642
}

-----------------------------------------------------分  割  线--------------------------------------------------------

 

  • 8.枚举
enum Singleton8{
    INSTANCE;

    public void sayOK(){
        System.out.println(" OK! ");
    }
}



/**
 * 枚举
 * 优缺点：借助JDK 1.5中添加枚举来实现单例模式，不仅能避免多线程同步问题，还能防止反序列化重新创建对象
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Singleton8 singleton1 = Singleton8.INSTANCE;
    Singleton8 singleton2 = Singleton8.INSTANCE;
    System.out.println(singleton1 == singleton2); // true
    System.out.println(singleton1.hashCode()); // 366712642
    System.out.println(singleton2.hashCode()); // 366712642
    singleton1.sayOK();
}

-----------------------------------------------------分  割  线--------------------------------------------------------

总结：

  • 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要反复频繁创建销毁的对象，使用单例模式可以提升系统的性能；
  • 当想实例化一个单例类的时候，记住必须使用相应的获取对象的方法，不能使用new;
  • 单例模式的使用场景：
  1. 需要频繁创建和销毁的对象；
  2. 创建对象耗时较长或者资源较多，但又经常使用的对象，工具类对象，频繁访问数据库或文件的对象；
设计模式-单例模式-注册式单例模式-枚举式单例模式和容器式单例模式在Java中的使用示例
BADAO_LIUMANG_QIZHI的博客
10-28 1272
上面讲了单例模式的三种方式，另外还有一种注册式单例模式。
嵌入式C语言设计模式 --- 单例模式
EmbedIoT Studio
12-29 2636
单例模式（Singleton Pattern）是软件程序设计中最简单的设计模式之一，单例模式在设计模式分类中，是属于创建型模式，它提供了一种创建对象（实例，变量）的最佳实践方式。顾名思义，单例（也叫单件），也就是在整个程序设计中，只存在一个单一的类（C语言中叫“类型”，通常用结构体类型表示），这个类负责创建一个对象（C语言中叫“定义变量”，通常是指结构体变量）
JAVA设计模式--单例模式
JAVA_SR的博客
09-21 935
单例设计模式
C#设计模式--单例模式
weixin_53545579的博客
04-29 1178
普通单例：一进门就把所有家具都准备好（程序启动时就创建实例）懒加载单例：等你要用沙发时才去买沙发（第一次访问时才创建实例）
JavaScript设计模式 -- 单例模式
u014676858的博客
02-11 1214
单例模式的核心思想是保证一个类只有一个实例存在，并提供一个全局访问点来获取该实例。这样可以防止重复创建对象，节省资源，同时也便于全局共享数据或状态。单例模式的特点：唯一性：在系统中只有一个实例存在。全局访问：提供一个全局访问点，让其他对象能够轻松地获取这个实例。延迟实例化：通常采用懒加载方式，只有在第一次使用时才创建实例。单例模式是一种简单但十分有用的设计模式，通过确保全局唯一实例，可以为配置管理、日志记录、事件总线、数据库连接等场景提供一致的解决方案。
Android 设计模式--单例模式
袁震的博客
11-11 1410
单例模式优点：1，单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁的创建，销毁时，单例模式的优势就非常明显了2，由于单例模式只生成一个实例，所以，减少了系统的性能开销，当一个对象的创建需要比较多的资源时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决。缺点：1，单例模式一般没有接口，扩展很难2，单例对象如果持有context，很容易发生内存泄漏，此时需要注意，传递给单例对象的Context最好是Application Context。
设计模式-单例模式
HL_LOVE_C的博客
01-03 1790
单例模式是一种设计模式，它。就像是在一个软件系统中，某些资源或者对象只需要存在一个就可以满足系统的需求，比如系统的配置管理器、数据库连接池等。通过单例模式，可以避免创建多个实例导致的资源浪费、数据不一致等问题。
设计模式--单例模式详解
想着百万年薪努力的小赵
04-13 2555
单例模式的定义 单例模式(Singleton Pattern ）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛，例如，公司CEO、部门经理等。J2EE标准中的ServletContext，ServletContextConfig等、Spring框架应用中的ApplicationContext、数据库的连接池等也都是单例形式。 饿汉式单例模式 饿汉式单例模式在类加载的时候就立即初始化，并且创建单例对象。它绝对线程安全，在线程还没 出
Java设计模式--单例模式（懒汉式实现）
qq_65225921的博客
11-13 2191
​ 单例模式是一种常见的设计模式，目的是确保一个类只会存在一个实例，并且该类提供全局进行访问此实例的方法。本文提供懒汉式的实现方案。
Java设计模式--单例模式（饿汉式实现）
qq_65225921的博客
11-12 1808
单例模式是一种常见的设计模式，目的是确保一个类只会存在一个实例，并且该类提供全局进行访问此实例的方法。
Python设计模式-单例模式
Aerkui的博客
04-10 793
简单场景：模块变量需要继承：装饰器或元类多线程环境：带锁实现需要缓存功能：lru_cache最佳实践：除非确需全局唯一实例，否则优先考虑依赖注入等更灵活的模式。
设计模式-单例模式（Singleton）
miaoyl的博客
11-03 2281
Java 单例模式（Singleton）是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点。这种模式通常用于需要频繁创建和销毁的对象，例如数据库连接、线程池等。
设计模式 -- 单例模式
qq_34552942的博客
12-22 1195
设计模式 -- 单例模式。
C++设计模式--单例模式
weixin_47755728的博客
08-03 1286
单例模式指的是，无论怎么获取，永远只能得到该类类型的唯一一个实例对象构造函数私有化，这样用户就不能任意定义该类型的对象了定义该类型唯一的对象通过一个static静态成员方法返回唯一的对象实例。
0-3论软件设计模式及其应用、2016-已写（观察者通知，命令-控制指令，适配器-兼容，工厂-多种数据库）
qianshanxue11的博客
12-25 802
最重要的是，这些模式都是一些经过反复使用的成熟设计方案，符合面向对象中设计规范，比如：面向接口编程、里氏替换原则、单一职责原则、依赖倒转等设计原则，最大限度的提高软件的标准化，为日后的系统维护打下了很好的基础。这方面，我们还缺少相关的经验。常见的行为型模式有解释器模式，终结者模式，策略模式，备忘录模式，命令模式，职责链模式，中介者模式等11种模式。创建型模式，主要负责对象的创建工作，程序在确定需要创建对象时，可以获得更大的灵活性，常见的创建型设计模式有单例模式，工厂方法，原型，抽象工厂，建造者模式。
二十三种设计模式(十五)--访问者模式
万波的技术博客
12-28 189
访问者模式是一种行为设计模式，允许在不修改现有类结构的情况下动态添加新操作。示例中通过定义Visitor接口和WorkVisitor实现类，为Teacher、Programmer和Cooker等稳定类新增work功能演示访问者模式代码结构
设计模式-观察者模式
weixin_46515691的博客
12-27 807
例如，在一个电商系统中，如果要新增一种促销活动通知方式（新的观察者），只需要实现相应的观察者类并注册到促销活动主题中即可，无需修改主题和其他观察者的代码。例如，观察者A的处理结果可能会影响观察者B的处理逻辑，但由于通知顺序的不确定性，可能会先通知B再通知A，从而导致错误的结果。具体主题是主题的具体实现类，它继承或实现主题接口，并实现主题定义的注册、移除和通知等方法。这在很多场景下非常有用，比如系统状态的更新需要通知多个不同的模块，通过观察者模式可以轻松实现这种广播式的通知。
设计模式：实战概要
最新发布
技术分析
12-29 792
设计模式不是 “银弹”，而是解决特定问题的工具。掌握设计模式的关键，不是死记硬背代码结构，而是理解模式背后的设计思想——高内聚、低耦合、开闭原则，这样才能在面对复杂业务场景时，灵活选择合适的模式。
c++ 语言教程——17面向对象设计模式（六）
mwl0223的博客
12-25 892
本文介绍了三种行为型设计模式：访问者模式、中介者模式和解释器模式。访问者模式通过分离数据结构与操作，支持在不修改元素类的情况下添加新操作，适用于操作频繁变化的场景，但会破坏封装性。中介者模式通过引入中介对象来协调多个对象间的交互，降低耦合度，适用于需要集中管理复杂交互的系统。文章通过C++代码示例分别展示了访问者模式在商品计价场景的应用，以及中介者模式在聊天室系统中的实现，分析了各自的优缺点和适用场景。
C#实现的23种设计模式-单例模式解析
"该文档是关于23种经典设计模式的C#版本介绍，主要讨论了其中的一种——单例模式（Singleton Pattern）。" 在软件工程中，设计模式是一种被广泛接受并反复使用的解决方案模板，用于解决常见的设计问题。单例模式是...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值