设计模式——单例模式

最新推荐文章于 2024-10-06 09:57:54 发布
最新推荐文章于 2024-10-06 09:57:54 发布
阅读量308 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 单例模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxcyblbq/article/details/121671993
版权

基本介绍

        所谓单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供了一个取得其对象实例的方法（静态方法）比如Hibernate的SessionFactory。

实例分析

 单例设计模式总共有八种实现方式：

1、饿汉式（静态变量）

代码实现：

        将构造器私有化，在类内部创建对象，向外暴漏一个静态的公共方法。

class Singleton{
    private Singleton() {

    }
    private final static  Singleton instance = new Singleton();

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


public static void main(String[] args) {
    Singleton instance1 = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();
    System.out.println(instance1 == instance2); // true
}

 总结：

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

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

代码实现：

class Singleton{
    private Singleton() {
    }
    private static Singleton instance;
    static {
        instance = new Singleton();
    }
    public static Singleton getInstance() {
        return instance;
    }
}

public static void main(String[] args) {
    Singleton instance1 = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();
    System.out.println(instance1 == instance2); // true
}

总结：

        同上一种方式。

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

代码实现：

class Singleton{
    private static Singleton instance;
    private  Singleton() {}
    // 提供一个静态方法，当使用到该方法时，采取创建instance
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return  instance;
    }
}


public static void main(String[] args) {
    Singleton instance1 = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();
    System.out.println(instance1 == instance2); // true
}

总结：

  1. 起到了Lazy Loading的效果，但是只能在单线程下使用。
  2. 如果多线程下，一个线程进入了if (instance == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。
  3. 在实际开发中不使用这种方式。

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

代码实现：

class Singleton {
    private static Singleton instance;
    private  Singleton() {}
    // 提供一个静态方法，加入了同步处理的代码，解决线程不安全问题
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}


public static void main(String[] args) {
    Singleton instance1 = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();
    System.out.println(instance1 == instance2); // true
}

总结：

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

5、懒汉式（线程安全，同步代码块）

代码实现：

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


public static void main(String[] args) {
    Singleton instance1 = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();
    System.out.println(instance1 == instance2); // true
}

总结： 

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

6、双重检查

代码实现：

class Singleton {
    private static volatile Singleton instance;
    private Singleton(){}
    // 提供一个静态公共方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public static void main(String[] args) {
    Singleton instance1 = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();
    System.out.println(instance1 == instance2); // true
}

总结：

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

7、静态内部类

代码实现：

class Singleton {
    private Singleton() {}
    // 写一个静态内部类，该类中有一个静态属性
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    public static synchronized Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

public static void main(String[] args) {
    Singleton instance1 = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();
    System.out.println(instance1 == instance2); // true
}

总结：

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

8、枚举

代码实现：

enum Singleton {
    INSTANCE;
}

public static void main(String[] args) {
    Singleton instance1 = Singleton.INSTANCE;
    Singleton instance2 = Singleton.INSTANCE;
    System.out.println(instance1 == instance2);
}

总结：

  1. 此方法不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
  2. 推荐使用。

总结

优点缺点总结
饿汉式（静态变量）写法简单，在类装载的时候就完成实例化，避免了线程同步问题。在类装载的时候就完成了实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

JDK中的Runtime类使用这种方法。

此方式可能会造成内存浪费。

饿汉式（静态代码块）写法简单，在类装载的时候就完成实例化，避免了线程同步问题。如果从始至终从未使用过这个实例，则会造成内存的浪费。此方式可能会造成内存浪费。
懒汉式（线程不安全）起到了Lazy Loading的效果，但是只能在单线程下使用。如果多线程下，一个线程进入了if (instance == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

在实际开发中不使用这种方式。

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

解决了线程不安全问题。

效率太低，每个线程想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行了一次实例化代码就够了，后面想获得该类实例直接return即可。实际开发中，不推荐使用。
懒汉式（线程安全，同步代码块）对第四种实现方式进行改进，解决效率低下问题。不能起到线程同步的作用。会造成同第三种方式一样的问题。实际开发中，不能使用这种方式。
双重检查

保证线程安全，避免了反复进行方法同步。

延迟加载，效率较高。

在实际开发中，推荐使用。
静态内部类

保证了线程的安全性。

利用静态内部类特点实现延迟加载，效率高。

在实际开发中，推荐使用。
枚举不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。在实际开发中，推荐使用。

 如上表格所示：实际开发中推荐使用后三种方法；在单线程环境下，可以使用前两种方法。

注意事项和细节说明

  1. 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
  2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new。
  3. 单例模式的使用场景：需要频繁的进行创建和销毁的对象；创建对象时耗时过多或者耗费资源过多（即：重量级对象），但又经常用到的对象、工具类对象；频繁访问数据库或文件的对象（比如：数据源、session工厂等）。
zxcyblbq
关注
专栏目录
java设计模式——单例模式
12-22
【Java设计模式——单例模式】 单例模式是一种常见的软件设计模式，它的核心思想是确保在应用程序的整个生命周期中，某个类只有一个实例存在。这种模式主要用于控制类的实例化过程，减少系统资源的消耗，提高系统...
C++设计模式——单例模式
jiaoooooo的博客
05-06 1629
文章目录前言一、饿汉模式二、懒汉模式1.简易版2.局部静态变量保证线程安全（c++11新标准）3.使用静态类析构4.使用智能指针析构总结 前言 一个类中只产生一个对象，并提供一个外部访问点，被程序全员共享，简化了在复杂环境下的配置管理，这种模式被成为单例模式。 一、饿汉模式 不管用不用，在程序开始就加载，会导致程序启动慢，且如果有多个单例类对象实例启动顺序不确定 线程安全，一共只生成一个静态对象 /* * HungerSingleton.h */ #pragma once #ifndef _HUNGER
C++ 设计模式——单例模式
qq_68194402的博客
08-22 1930
单例模式（Singleton Pattern）也称单件模式/单态模式，是一种创建型模式，用于创建只能产生一个对象实例的类。
设计模式 —— 单例模式
weixin_44814196的博客
09-04 655
单例模式（Singleton Pattern）是一个比较简单的模式，其定义如下：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
探索设计模式——单例模式详解
strive_mianyang的博客
06-18 1677
单例模式的简单讲解
C++设计模式——单例模式-附件资源
03-05
C++设计模式——单例模式-附件资源
设计模式——单例模式（懒汉模式）
08-10
单例模式是软件设计模式中的一种经典模式，它保证了类在任何情况下都只有一个实例存在。这个模式在很多场景下非常有用，例如控制全局资源、管理配置信息等。本文将详细探讨单例模式的懒汉式实现，并结合源码进行解析...
Prototype(原型模式)
TimerSea的博客
10-06 517
本篇介绍了原型设计模式基础与实现示例
设计模式-模版方法模式
ZSS1753936255的博客
10-04 695
模版方法模式(Template Method):定义一个操作中的算法骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重新定义算法的某些定义步骤。抽象类：负责实现一个算法的骨架，他是由一个final修饰的模版方法和若干个基本方法组成的。
设计模式-适配器模式
最新发布
m0_45164511的博客
10-06 596
适配器模式（Adapter Pattern）属于结构型设计模式，它的作用是。适配器让原本由于接口不兼容而不能一起工作的类可以协同工作。适配器模式包括三个角色：目标抽象类（Target）、适配器类（Adapter）和被适配者类（Adaptee）。适配器模式在实际开发中非常常见，比如我们经常需要连接各种不同的数据库，每种数据库都有自己独特的接口和方法。如果我们希望写出一段通用的代码，能够连接到任何一种数据库并执行相同的操作，那么适配器模式就非常适合解决这个问题。
设计模式之原型模式(通俗易懂--代码辅助理解【Java版】）
qq_45929019的博客
10-04 1117
创建型模式：工厂方法、抽象方法、建造者、原型、单例。结构型模式有：适配器、桥接、组合、装饰器、外观、享元、代理。行为型模式有：责任链、命令、解释器、迭代器、中介、备忘录、观察者、状态、策略、模板方法、访问者。常用设计模式：单例模式、工厂模式、代理模式、策略模式&模板模式、门面模式、责任链模式、装饰器模式、组合模式、builder模式。这种情况就是浅拷贝，java只拷贝你指定的对象，至于你指定的对象里面的别的对象，它不拷贝，还是把引用给你，共享变量，这是一种非常不安全的方式，需要特别注意。
设计模式-原型模式
ZSS1753936255的博客
10-02 606
设计模式
设计模式-工厂模式
ZSS1753936255的博客
10-02 837
工厂方法模式非常符合“开闭原则”，当需要增加一个新的产品时，我们只需要增加一个具体的产品类和与之对应的具体工厂即可，无须修改原有系统。同时在工厂方法模式中用户只需要知道生产产品的具体工厂即可，无须关系产品的创建过程，甚至连具体的产品类名称都不需要知道。由此发现：都是先创建工厂，然后在使用工厂实例获取产品。此时只有一个工厂，那么只能创建一类型的产品。当系统中加入新产品时，除了需要提供新的产品类之外，还要提供与其对应的具体工厂类。而工厂子类则负责生成具体的产品对象，即通过不同的工厂子类来创建不同的产品对象。
设计模式-抽象工厂模式
ZSS1753936255的博客
10-02 543
写代码的时候，我们先会以一下 工厂方法模式，工厂方法只有一个抽象父工厂，只有一个 父产品。所以先获取工厂实例后，通过工厂实例对象来决定 获取具体的产品。抽象工厂:提供一个接口，可以创建一系列相关或者相互依赖的对象，而无需制定他们具体的类。我们的现在的需求是:用瓶子来装可乐，可能是塑料瓶子，也可能是 玻璃瓶子。（个人建议先看完上文的简单工厂：抽象工厂是在简单工厂的基础上对比出来的。-- 可乐可乐（CocaCola）-- 玻璃瓶子（GlassBox）-- 金瓶子 （GoldBox）可乐瓶子(ColaBox)
设计模式-组合模式
ZSS1753936255的博客
10-03 662
组合模式（Composite）:将对象组合成树型结构以表示“整体-部分”的层次结构，是的用户对单个对象和组合对象的使用具有一致性。比如常见请求的DTO,VO这些东西。
设计模式-装饰器模式
ZSS1753936255的博客
10-03 604
比派生子类的灵活的原因就是：举例，原本的一个接口的一段公用代码，你这边为了满足你的需求，你直接对原有的代码上手修改，但是可能会不兼容其他第三方对这个接口的业务依赖。而你使用装饰者模式，动态通过装饰者类来装饰扩展，并不会影响原有的逻辑。原理就是：装饰者 重写了 被 装饰者 Source接口中的method方法 且 关联了 被装饰者。关联了被装饰者的对象的目的就是，就是希望调用 被装饰者的原有方法，在原有的基础上添加了 额外的基础。就可以 用 不同的装饰者子类可以 对于被装饰者 就有不同的 额外职责展示）。
设计模式-观察者模式
ZSS1753936255的博客
10-03 547
观察者模式也可以理解为 发布-订阅模式。Subject就是主题对象，也就是被观察者。负责添加了 观察者对象（Observer就是观察者对象），并且通知 notify 所有的观察者（订阅者对象）观察者模式（Observer）:定义对象间的一种一对多的依赖关系，当一个对象的状态发生变更时，所有依赖于他的对象都得到通知并自动更新。Credit就是观察者对象。当具体的Dredit对象的状态发生变化时。就需要通知所有的观察者来要钱。Dredit就是被观察者对象，而。
Java面试：设计模式详解——单例、工厂、抽象工厂与代理模式
"本文主要介绍了Java面试中常见的几种设计模式，包括单例模式、工厂模式、抽象工厂模式、代理模式以及MVC模式，并通过实际例子帮助理解这些模式的原理和应用。" ### 单例模式 单例模式是一种限制类只能拥有一个实例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值