一、单例模式（Singleton Pattern）

最新推荐文章于 2024-11-03 23:39:20 发布
最新推荐文章于 2024-11-03 23:39:20 发布
阅读量211 收藏
点赞数
分类专栏： 04.设计模式 文章标签： 设计模式 单例模式 java 双重检查
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KJGMan/article/details/89307149
版权

文章目录

一、概述

单例模式是指在整个软件系统中，一个类只有一个实例对象，并且该类需要提供访问该实例对象的方法（静态方法）

二、UML图

在这里插入图片描述

三、适用场景

  1. 当需要频繁的创建和销毁对象，并且创建对象耗时较长，资源消耗较多，但是会经常使用到的对象，就需要使用单例模式

四、特点

  1. 一个类只有一个实例

五、单例模式的7种实现形式

1）饿汉式（静态常量）

  • 示例
public class Singleton_01 {

    private static final Singleton_01 instance = new Singleton_01();

    private Singleton_01(){}

    public static Singleton_01 getInstance() {
        return instance;
    }
}

class Test_01 {

    public static void main(String[] args){
        Singleton_01 instance1 = Singleton_01.getInstance();
        Singleton_01 instance2 = Singleton_01.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1 hash code: " + instance1.hashCode());
        System.out.println("instance1 hash code: " + instance2.hashCode());
    }
}
  • 优缺点说明
  1. 优点：写法简单，在类加载完成后就完成了初始化，避免了线程同步的问题
  2. 缺点：在类加载完成后完成了实例化，没有达到Lazy Loading的效果，如果系统从始至终没有使用过该实例，便造成了内存的浪费
  3. 说明：这种方式基于ClassLoader机制（ClassLoader机制本身是线程安全的）避免了多线程的同步问题，但是，其实例会在类加载完成之后立即完成了初始化；如果由于其他原因，导致了该类的加载，便会导致该类的实例被初始化，没有达到Lazy Loading的效果
  4. 结论：写法简单，但是可能会造成内存浪费；如果确定实例会使用，建议使用

2）饿汉式（静态代码块）

  • 示例
public class Singleton_02 {

    private static Singleton_02 instance;

    static {
        instance  = new Singleton_02();
    }

    private Singleton_02(){}

    public static Singleton_02 getInstance() {
        return instance;
    }
}

class Test_02 {

    public static void main(String[] args){
        Singleton_02 instance1 = Singleton_02.getInstance();
        Singleton_02 instance2 = Singleton_02.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1 hash code: " + instance1.hashCode());
        System.out.println("instance1 hash code: " + instance2.hashCode());
    }
}
  • 优缺点说明
  1. 同饿汉式静态常量的方式一样，只不过把示例的初始化过程放在了静态代码块中；

3）懒汉式（线程不安全）

  • 示例
public class Singleton {

    private static Singleton instance;

    private Singleton(){}

    public static Singleton getInstance() {
        if (instance == null)
            instance = new Singleton();
        return instance;
    }
}

class Test_02 {

    public static void main(String[] args){
        // 多线程下测试线程不安全问题(执行多次, 会发现输出的hashCode不同)
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                Singleton instance = Singleton.getInstance();
                System.out.println(instance.hashCode());
            }, "T-" + i).start();
        }
    }
}
  • 优缺点说明
  1. 起到了Lazy Loading的效果，但是线程不安全
  2. 在多线程环境下，两个线程同时执行到if (instance == null)，若为true，则会创建两个不同的实例
  3. 多线程环境下不能使用该形式去创建单例

4）懒汉式（线程安全，同步方法）

  • 示例
public class Singleton {

    private static Singleton instance;

    private Singleton(){}

    public synchronized static Singleton getInstance() {
        if (instance == null)
            instance = new Singleton();
        return instance;
    }
}

class Test {

    public static void main(String[] args){

        // 多线程下测试线程不安全问题(执行多次, 线程安全)
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                Singleton instance = Singleton.getInstance();
                System.out.println(instance.hashCode());
            }, "T-" + i).start();
        }
    }
}
  • 优缺点说明
  1. 使用synchronized修饰静态方法, 保证了线程安全
  2. 但是每次调用getInstance方法时, 都需要获取锁, 增加等待时间, 效率较低

5）双重检查

public class Singleton {

    private volatile static Singleton instance;

    private Singleton(){}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

class Test {

    public static void main(String[] args){

        // 多线程下测试线程不安全问题(执行多次, 线程安全)
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                Singleton instance = Singleton.getInstance();
                System.out.println(instance.hashCode());
            }, "T-" + i).start();
        }
    }
}
  • 优缺点说明
  1. Double-Check概念是多线程开发中常用的方式；示例中进行了两次if(instance == null)的检查，第一次检查是为了在创建对象时，判断对象是否为空，若为空则进行创建对象；第二次检查，并且加了同步锁，为了避免多线程情况下，两个线程同时通过了第一次检查，都进入了创建对象的步骤，第二次加锁检查，就只能允许一个线程进行对象的创建
  2. 确保了实例化代码只需要执行一次，后面再次访问时，直接返回实例化之后的对象
  3. 线程安全，延迟加载，效率较高；实际开发中推荐使用

6）静态内部类

public class Singleton {

    private volatile static Singleton instance;

    private Singleton(){}

    public static Singleton getInstance() {
        return InnerSingleton.INSTANCE;
    }

    private static class InnerSingleton {
        private static final Singleton INSTANCE = new Singleton();
    }
}

class Test {

    public static void main(String[] args){

        // 多线程下测试线程不安全问题(执行多次, 线程安全)
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                Singleton instance = Singleton.getInstance();
                System.out.println(instance.hashCode());
            }, "T-" + i).start();
        }
    }
}
  • 有缺点说明
  1. 采用了类装载的机制保证了线程安全
  2. 静态内部类InnerSingleton在Singleton类被加载时不会立即被初始化，而是在调用getInstance方法时才会对InnerSingleton进行加载操作，加载InnerSingleton会对静态常量进行初始化操作
  3. 利用静态内部类延迟加载的特性实现了懒加载，效率较高

7）枚举

  • 示例
public class Test {

    public static void main(String[] args){
        Singleton instance = Singleton.INSTANCE;
        instance.method();
    }
}

enum Singleton {
    INSTANCE;

    public void method() {
        System.out.println("Do Something!");
    }
}
  • 优缺点说明
  1. 枚举保证了线程安全
  2. 枚举可以避免反序列化时重复创建对象

六、spring中的单例

1、spring中单例bean的创建流程

1.1 注册初始的BeanDefinition，此时scope属性为空
  1. 调用DefaultListableBeanFactory#registerBeanDefinition方法
  2. 此时只是初始化了部分BeanDefinition（Spring的基础Bean，及main方法所在的Bean）
1.2 初始化scope
  1. 调用AbstractBeanFactory#getMergedBeanDefinition，将scope为空的BeanDefinition设置为singleton
if (!StringUtils.hasLength(mbd.getScope())) {
	mbd.setScope(SCOPE_SINGLETON);
}
1.3 注册业务Bean·

七、单例模式的破坏

1、反射的方式破坏单例

☞ 原理

通过反射的方式，获取到私有的构造器，设置可以访问私有构造器的权限，然后通过反射调用的方式去创建实例

public class Reflect {

    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("com.lizza.d1_singleton.singleton_1.Singleton");
        Constructor<?> constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton instance_1 = (Singleton) constructor.newInstance();
        Singleton instance_2 = (Singleton) constructor.newInstance();
        System.out.println(instance_1.hashCode());
        System.out.println(instance_2.hashCode());
    }
}
☞ 如何避免

在私有构造器中进行判空处理

private Singleton(){
    if (instance != null) {
        throw new RuntimeException("instance is must be null!");
    }
}

2、序列化和反序列化破坏单例

☞ 原理

通过对象序列化可以得到不同的克隆对象，以此来破坏单例

public class Serialize {

    public static void main(String[] args){
        // 传统单例
        com.lizza.d1_singleton.singleton_1.Singleton instance = com.lizza.d1_singleton.singleton_1.Singleton.getInstance();
        // 枚举: 可以避免序列化破坏单例的情况
//        com.lizza.d1_singleton.singleton_7.Singleton instance = com.lizza.d1_singleton.singleton_7.Singleton.INSTANCE;
        Object object = clone(instance);
        System.out.println(instance.getClass() + ", " + instance.hashCode());
        System.out.println(instance.getClass() + ", " + object.hashCode());
    }

    public static Object clone(Object object) {
        ObjectInputStream is = null;
        ObjectOutputStream os = null;
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            os = new ObjectOutputStream(bos);
            os.writeObject(object);
            is = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
            
            return is.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (os != null) {
                    os.close();
                }
                if (is != null) {
                    is.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}
☞ 解决方式

在Singleton中增加readResolve方法，反序列化时会判断是否有readResolve方法, 若有则通过该方法创建对象

/** 反序列化时会判断是否有readResolve方法, 若有则通过该方法创建对象 **/
private Object readResolve() {
    System.out.println(">>> readResolve is run!");
    return getInstance();
}

参考

【1】破坏单例模式
【2】为什么推荐使用枚举来创建单例
Lizza~
关注
专栏目录
Singleton单例模式
TheSeasonSun的博客
04-13 636
设计模式之单例模式
单例模式 Singleton Pattern
03-09
### 单例模式 Singleton Pattern #### 概述 单例模式是一种常见的设计模式，属于创建型模式之一。这种模式的核心在于确保某个类只有一个实例存在，并且提供一个全局访问点来获取该实例。单例模式在Java开发中尤其...
设计模式-单例模式（Singleton Pattern）
weixin_60653563的博客
08-22 1372
单例模式。饿汉式单例；懒汉式；枚举式单例；容器式单例；ThreadLocal式单例。
【设计模式】——单例模式（Singleton Pattern）
J^T的博客
08-05 2086
单例模式（Singleton Pattern）是这些设计模式中的一种，它提供了一种创建对象的最佳方式，确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。这种模式在需要严格控制资源访问、管理全局状态或实现共享资源访问时非常有用。
单例模式Singleton Pattern
zlb25246的专栏
08-23 164
Singleton Pattern
【设计模式】单例模式 Singleton Pattern
神也在Cpoy
02-17 1305
Java的对象，通常需要我们new出来，大多数时候，应对这种情况，我们很容易想到，只保持一个对象，并提供全局的访问，在并发的场景下，让它线程安全。
设计模式-单例模式Singleton Pattern
超级马里奥 的博客
10-26 408
一.单例模式的概念 单例模式（Singleton Pattern）属于创建型模式； 单例模式涉及一个单一的类，该类只负责创建自己的对象，并且保证只有一个对象被创建，该类提供一种访问其唯一的对象的方式； 单例模式必须自己创建自己的唯一实例； 二.代码实例 1. ...
单例模式（Singleton Pattern）
奶油芝士蘑菇汤的博客
03-07 179
一、定义 单例模式（Singleton Pattern）：创新型模式之一，保证一个类仅有一个实例，并提供一个访问它的全局访问点。 二、UML类图 三、代码实现 单例模式有两种类型：饿汉式、懒汉式。 饿汉式：在类加载时就已经创建好了该单例对象，等待被程序调用。 public class EarlySingleton { private static EarlySingleton singleton = new EarlySingleton(); private EarlySinglet
C# 单例模式（Singleton Pattern）
qq_42209596的博客
01-18 518
1、实例控制：Singleton 会阻止其他对象实例化其自己的 Singleton 对象的副本，从而确保所有对象。4、Singleton模式一般不要支持序列化，这也有可能导致多个对象实例，这也与Singleton模式的初。5、Singleton只考虑了对象创建的管理，没有考虑到销毁的管理，就支持垃圾回收的平台和对象的开。7、可以很简单的修改一个Singleton，使它有少数几个实例，这样做是允许的而且是有意义的。在软件系统中，经常有这样一些特殊的类，必须保证它们在系统中只存在一个实例，才能确保它们。
python简单学 单例模式【Singleton Pattern】
m0_38096164的博客
02-15 441
本文介绍了在 Python 中实现单例模式的方法，并提供了两种不同的实现方式。首先，我们讨论了如何使用特殊方法 __new__ 来创建一个单例类，以确保在程序运行期间只有一个实例存在。接着，我们展示了如何通过创建一个基类，并让需要单例模式的类继承这个基类来实现单例模式。最后，我们讨论了释放单例模式实例的方式，尽管 Python 的垃圾回收机制会自动释放不再被引用的对象，但我们也提供了一种手动释放单例实例的方法。通过本文的介绍，读者可以了解到单例模式的实现原理以及如何在 Python 中应用它来管理全局状态和
C#单例模式(Singleton Pattern)详解
08-29
C#单例模式（Singleton Pattern）是一种常用的设计模式，用于确保一个类只有一个实例，并提供一个全局访问点。下面我们将详细介绍C#单例模式的定义、实现和优化。 单例模式的定义： 单例模式的主要目的是确保一个...
c++-设计模式之单例模式（Singleton Pattern）
09-18
单例模式（Singleton Pattern）是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。这种模式常用于需要全局共享资源的场景，比如配置管理、日志记录等。 单例模式的组成 私有构造函数：防止外部...
[创建型模式] 单例模式（Singleton Pattern）
01-20
一个类可以创建多个对象，这是面向对象的语言特性，想要实现单例模式，就要屏蔽这个特性，防止系统可以随意创建类的对象。 要做到这一点，通常做法就是利用private关键字将类的构造方法私有化，使外部调用者无法利用...
远程控制项目第二天
最新发布
zhj18679130613的博客
11-03 118
所有有关网络编程的项目，最基础的框架就是那些固定的流程，Socket，bind，listen，accept，然后我需要的就是在此基础上进行完善和优化，然后再Windows网络编程中，在socket前首先需要初始化 Winsock 库。
设计模式概述
小林的博客
10-30 404
直到1995 年，艾瑞克·伽马（ErichGamma）、理査德·海尔姆（Richard Helm）、拉尔夫·约翰森（Ralph Johnson）、约翰·威利斯迪斯（John Vlissides）等 4 位作者合作出版了《设计模式：可复用面向对象软件的基础》一书，在此书中收录了 23 个设计模式，这是设计模式领域里程碑的事件，导致了软件设计模式的突破。GoF（四人组）书中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等 11 种行为型模式。
【Java】设计模式——单例设计模式
啊松同学的博客
11-02 569
单例设计模式介绍
微服务设计模式 - 发布订阅模式（Publisher Subscriber Pattern）
2404_88048702的博客
11-02 839
发布-订阅模式是实现松耦合系统的强大工具，在云计算和分布式系统中应用广泛。通过使用如RabbitMQ的消息中间件，我们可以很容易地在Spring Boot项目中实现这一模式。通过本文的示例，我们展示了如何利用配置消费者行为，并通过Spring Boot注解进行订阅，从而实现发布-订阅模式的精细化控制和一个完整的发布-订阅模式。这种模式不仅提高了系统的扩展性和灵活性，还大大简化了开发过程中的依赖管理。
设计模式——外观模式
chuliling0446的博客
10-30 1056
这些是实现具体功能的类，它们组成了一个子系统。子系统类之间可能存在复杂的交互和依赖关系，这些关系对于客户端来说可能是难以理解和操作的。外观类是外观模式的核心，它知道哪些子系统类负责哪些功能，并将客户端的请求转发给相应的子系统类来处理。外观类提供了一个简化的接口，隐藏了子系统类的复杂性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值