设计模式之单例模式

最新推荐文章于 2024-11-12 21:35:51 发布
最新推荐文章于 2024-11-12 21:35:51 发布
阅读量1k 收藏 15
点赞数 26
分类专栏： C++学习 C# Web应用技术学习 文章标签： 设计模式 单例模式 java c++ c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liukuande/article/details/138349393
版权

单例模式

一、单例模式概述

在这里插入图片描述

1.单例模式的定义

单例模式（Singleton Pattern）是一种常用的软件设计模式。在这种模式中，一个类负责创建自己的对象，同时确保只有单个对象被创建了。这个类提供了访问其对象的方式。

2.单例模式的作用

单例模式使得我们在使用一个类及其对象时，不必频繁地进行创建和销毁，提高了程序的性能，节约了系统资源。单例模式常常在以下场景中使用：

  1. 资源共享: 当应用程序需要共享某个资源（如数据库连接、日志记录器、线程池等）时，可以使用单例模式确保所有对象共享同一个实例，避免资源的重复创建和浪费。

  2. 配置管理器: 在需要全局访问配置信息的情况下，可以使用单例模式来管理配置信息的加载和访问，确保所有组件都使用相同的配置实例。

  3. 日志记录器: 单例模式可以用于创建全局的日志记录器，以便在整个应用程序中记录日志并保持日志的一致性。

  4. 线程池: 在需要管理和控制线程的情况下，可以使用单例模式来创建线程池，确保所有线程共享同一个线程池实例，并且能够动态地调整线程池的大小。

  5. 缓存管理器: 当需要缓存某些数据以提高应用程序的性能时，可以使用单例模式来创建全局的缓存管理器，以确保所有组件都使用相同的缓存实例。

  6. 窗口管理器: 在图形用户界面（GUI）应用程序中，可以使用单例模式来创建窗口管理器，以确保所有窗口共享同一个实例，并且能够动态地管理和控制窗口的显示和隐藏。

3.单例模式的优缺点

优点:

  1. 资源节约：由于系统中只存在一个对象，可以节约系统资源，尤其是对象创建和销毁成本高时，单例模式可以提高系统性能。
  2. 全局访问点：提供了对唯一实例的受控访问，方便全局调用。
  3. 共享资源：适用于控制资源访问，如配置管理和日志记录，确保资源的协调与共享。
  4. 避免重复实例：防止其他对象对自己的实例化，确保所有对象都访问同一个实例。

缺点:

  1. 扩展困难：由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
  2. 职责过重：单例类的职责过重，可能违背了“单一职责原则”，一个类既负责业务逻辑又负责生命周期管理。
  3. 灵活性受限：不利于代码的测试，特别是依赖于单例类的代码。在单元测试中，需要模拟不同的单例对象，单例模式的单一实例特性对此造成了阻碍。
  4. 多线程问题：在多线程环境下，如果不正确实现，可能会导致多个实例被创建，违反单例模式的原则。同时，在高并发的场景下，由于锁的存在，可能会导致线程阻塞，性能下降。

二、单例模式的实现

1.懒汉式

说明：延迟实例化的单例模式，即先不创建实例，当第一次被调用时，再创建实例。

代码：

C++版本：
class Singleton {
private:
    // 私有静态指针变量，用于保存类的唯一实例
    static Singleton* instance;

    // 构造函数私有化
    Singleton() {}

	// 防止拷贝构造和赋值操作
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

public:
    // 提供全局访问点
    static Singleton* GetInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;
C#版本：
    public class Singleton
    {
        // 定义一个静态变量来保存类的实例
        private static Singleton instance;

        //构造函数私有化
        private Singleton()
        {
        }

        //一个公有的静态函数，用于提供全局唯一的访问点
        public static Singleton GetInstance()
        {
            if (instance == null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }

优点：

延迟了实例化，如果不需要使用类，则不进行实例化，在使用时才进行实例化，避免了资源浪费

缺点：

线程不安全，在多线程环境夏，如果有多个线程同时获取实例，都发现了类还没有进行实例化，即instance == nullptr，那么会有多个线程进行 instance = new Singleton()，就会产生多个实例。

2.饿汉式

说明：程序在加载时直接实例化好这个对象，后续需要使用的时候直接调用。

代码：

C++版本：
//实现一个饿汉式单例模式
class Singleton {
private:
	//私有静态成员变量，用于存储唯一实例
	static Singleton* instance;

	//私有构造方法，避免类在外部被实例化
	Singleton() {

	}

	//删除拷贝函数和赋值操作
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

public:
	//公有方法，提供全局唯一的访问点
	static Singleton* GetInstance() {
		return instance;
	}
};

// 初始化静态成员变量
Singleton* Singleton::instance = new Singleton();
C#版本：
    //实现一个饿汉式单例模式的类
    public class Singleton
    {
        //类加载时就创建实例
        private static readonly Singleton instance = new Singleton();

        //构造函数私有化
        private Singleton()
        {
        }

        public static Singleton GetInstance()
        {
            return instance;
        }

优点：

线程安全。

缺点：

如果被实例化的对象在本程序的声明周期中并未被使用，则会造成资源浪费。

3.线程安全的懒汉式

说明：通过在GetInstance()加锁来解决多线程情况下的线程不安全问题

代码：

C++版本：
//线程安全的懒汉式单例模式
#include <mutex>

class Singleton
{
private:
	//私有静态成员变量
	static Singleton* instance;
	static std::mutex mtx;

	//私有构造函数
	Singleton() {}

	//删除拷贝函数和赋值函数
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

public:
	static Singleton* GetInstance()
	{
		//线程安全的懒汉式单例模式，不使用双重锁机制
		//这行代码保证了只有一个线程可以进入临界区
		//临界区是指一个代码片段，一次只允许一个线程进入执行
		//在这里，临界区是整个GetInstance函数
		std::lock_guard<std::mutex> lock(mtx);
		if (instance == nullptr)
		{
			instance = new Singleton();
		}
		return instance;
	}
};

//静态成员变量初始化
Singleton* Singleton::instance = nullptr;
C#版本：
namespace 线程安全的懒汉式单例模式c_
{
    线程安全的懒汉式单例模式
    
    public class Singleton
    {
        //定义一个静态变量来保存类的实例
        private static Singleton uniqueInstance;
        //定义一个标识确保线程同步
        private static readonly object locker = new object();
        //定义私有构造函数，使外界不能创建该类实例
        private Singleton()
        {
        }

       
        public static Singleton GetInstance()
        {
            //当第一个线程运行到这里时，此时会对locker对象 "加锁"，
            //当第二个线程运行到这里时，首先检测locker对象为加锁状态，该线程就会挂起等待第一个线程解锁。
            //lock语句运行完之后（即线程运行完之后）会对该对象 "解锁"
            lock (locker)
            {
                //如果类的实例不存在则创建，否则直接返回
                if (uniqueInstance == null)
                {
                    uniqueInstance = new Singleton();
                }
            }
            return uniqueInstance;
        }
    }
}

优点：

延迟实例化，避免了资源浪费，同时通锁避免了多线程环境下的线程安全问题

缺点：

虽然解决了线程安全问题，在程序的生命周期内确保了只有一个实例，但每次获取实例时，只有拿到锁的线程才可以直接获取，造成了时间上的浪费，程序性能下降。

4.双重检查锁实现

说明：基于“线程安全的懒汉式”进行优化，通过改变锁的位置使得每次调用GetInstance()视情况加锁，优化了程序性能。

代码：

C++实现:
//使用双重检查锁机制实现的单例模式
#include <mutex>

class Singleton
{
	//私有静态成员变量
	static Singleton* instance;
	static std::mutex mtx;

	//私有构造函数
	Singleton() {}
	
	//删除拷贝函数和赋值函数
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

	//静态成员函数，提供全局唯一访问点
public:
	static Singleton* GetInstance()
	{
		//双重检查锁机制
		if (instance == nullptr)
		{
			std::lock_guard<std::mutex> lock(mtx);
			if (instance == nullptr)
			{
				instance = new Singleton();
			}
		}
		return instance;
	}
};

//静态成员变量初始化
Singleton* Singleton::instance = nullptr;
C#实现:
namespace 线程安全的懒汉式单例模式
{
    线程安全的懒汉式单例模式
    public class Singleton
    {
        //定义一个静态变量来保存类的实例
        private static Singleton uniqueInstance;
        //定义一个标识确保线程同步
        private static readonly object locker = new object();
        //定义私有构造函数，使外界不能创建该类实例
        private Singleton()
        {
        }

        //定义公有方法提供一个全局访问点，同时你也可以定义公有属性来提供全局访问点
        public static Singleton GetInstance()
        {
            //当第一个线程运行到这里时，此时会对locker对象 "加锁"，
            //当第二个线程运行到这里时，首先检测locker对象为加锁状态，该线程就会挂起等待第一个线程解锁。
            //lock语句运行完之后（即线程运行完之后）会对该对象 "解锁"
            if (uniqueInstance == null)
            {
                lock (locker)
                {
                    //如果类的实例不存在则创建，否则直接返回
                    if (uniqueInstance == null)
                    {
                        uniqueInstance = new Singleton();
                    }
                }
            }
            return uniqueInstance;
        }

    }
}

使用.NET4.0引入是lazy<T>实现等效效果，且性能更优。

namespace 线程安全的懒汉式单例模式
{
    线程安全的懒汉式单例模式

    public class Singleton
    {
        //使用lazy<T>类型的字段，确保线程安全
        //Lazy<T>是一个线程安全的延迟初始化类，它允许推迟对象的创建，直到第一次访问该对象时
        //对于创建十分耗时的对象，Lazy<T>类可以提高性能
        //此外，Lazy<T>类还可以保证线程安全
        private static readonly Lazy<Singleton> _instance = new Lazy<Singleton>(() => new Singleton());

        //私有构造函数，确保外部无法实例化
        private Singleton()
        {
        }

        //提供一个公共的静态方法，返回一个单例
        public static Singleton GetInstance()
        {
            return _instance.Value;
        }
    }
}

优点：

  • 延迟实例化，节约了资源
  • 线程安全，并且相对于直接加锁的懒汉式程序的整体性能更优

缺点：

可能会因为操作系统指令重排发生异常： uniqueInstance = new Singleton();这段代码的执行分为3步

  • 为uniqueInstance分配内存空间
  • 初始化uniqueInstance
  • 将uniqueInstance指向分配的内存空间
    由于指令重排，第一步和第三步可能在第二步之前，这样会出现这种情况：
    线程A正在进行第二步（一三步已经完成），在这时线程B也来访问这个类，发现这个类已经存在实例了，直接取用，但其实uniqueInstance还没有被初始化。

5.静态内部类实现

说明：静态内部类（Static Nested Class）是Java中的一种特殊类，它位于另一个类的内部并且使用static关键字进行修饰。

代码：

Java：
public class Singleton {  
    // 定义一个静态内部类SingletonHolder，用于实现Singleton实例的延迟加载
    private static class SingletonHolder {  
        // 在SingletonHolder类中声明一个静态final变量INSTANCE，用于保存Singleton的唯一实例
        private static final Singleton INSTANCE = new Singleton();  
    }
    
    // 将构造方法设为私有，防止外部直接通过new创建Singleton对象
    private Singleton (){}
    
    // 提供一个公共的静态方法getInstance，用于返回Singleton的唯一实例
    // 由于SingletonHolder是静态内部类，且INSTANCE是静态final变量，因此这里的加载是线程安全的
    public static final Singleton getInstance() {  
        // 直接返回SingletonHolder中的INSTANCE实例，实现懒汉式单例模式
        return SingletonHolder.INSTANCE;  
    }  
}
优点：延迟实例化，节约了资源，且线程安全，性能也被提高了。

枚举类实现

说明：枚举（Enum）是一种特殊的类，用于定义固定的常量集。在Java中，可以通过将枚举类型与实例化代码结合，天然地实现线程安全的单例模式，因为Java中的枚举实例创建是线程安全的，并且枚举类型的实例也是唯一的。

代码：

在C#中，lazy<T>可以实现类似效果。

Java：

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

优点：

写法简单，线程安全，天然防止序列化和反序列化。

三、感受

系统学完一个设计模式，不仅能够增加了软件开发的最佳实践相关经验，也能够考察对某一编程语言学习的深度和广度。

春风LiuK
关注
专栏目录
软件设计模式之单例设计模式
我吃柠檬的博客
08-12 351
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。它是一种创建型设计模式， 让你能够保证一个类只有一个实例， 并提供一个访问该实例的全局访问节点。
2021-09-23 软件设计之单例模式详解
抱住小羊的卷卷
09-23 206
一、软件设计模式 1、概念 软件设计模式（Design pattern），又称设计模式，是一套被反复使用，多数人知晓，经过分类编目、代码设计经验的总结。 2、作用 使用设计模式是为了可重用代码，让代码更容易被他人理解，保证代码可靠性和程序的重用性。 java有23种设计模式。 二、单例模式 单例模式（Singleton pattern）是java最简单的设计模式之一，属于创建型模式，它提供了一种创建对象的最佳方式。 单例模式要保证一个类仅有一个实例，并提供一个全局都可以访问的方式。 1、.
JAVA设计模式之单例模式
一个本科小生的奋斗史
04-16 99万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
快速理解设计模式：单例模式深入
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
PHP设计模式之单例模式定义与用法分析
01-03
单例模式（Singleton Pattern 单件模式或单元素模式），是常见的一种设计模式，它有三个特点 1．只能有一个实例 2．必须自行创建这个实例 3．必须给其他对象提供这一实例 下面用PHP代码实现一下 <?PHP /** *...
c#设计模式之单例模式的实现方式
12-26
单例模式对于我们来说一点也不模式，是一个常见的名称，单例模式在程序中的实际效果就是：确保一个程序中只有一个实例，并提供一个全局访问点，节省系统资源 单例模式无论是在实际开发中还是在软件应用中比较常见，...
【设计模式】结构型模式（四）：组合模式、享元模式
书山有路，学海无涯。记录成长，追逐梦想
11-09 916
组合模式（Composite Pattern）是一种设计模式，用于处理树形结构的数据。它的主要目的是将对象组合成树形结构来表示 “部分 - 整体” 的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
【设计模式】工厂模式
weixin_56520780的博客
11-11 355
把对象的创建封装在一个接口函数里面，通过传入不同的标识，返回创建的对象。客户不用自己负责new对象，不用了解对象创建的详细过程把有关联关系的，属于一个产品簇的所有产品创建的接口函数，放在一个抽象工厂里面AbstractFactory，派生类（具体产品的工厂）应该负责创建该产品簇里面所有的产品。假如一类工厂如宝马工厂多做了一项业务如轮胎，那么就得在抽象工厂里面增加一个创建轮胎的产品接口（纯虚函数），所有的工厂都得重写该接口，否则都成了抽象类...
【C#设计模式(6)——适配器模式(Adapter Pattern)】
weixin_43626218的博客
11-12 58
C#设计模式(6)——适配器模式(Adapter Pattern)适配器模式主要用于在不修改现有类的情况下，使本来不包含的类可以一起工作。
设计模式设计模式
hi_zf的博客
11-11 239
###创建型模式，共五种：结构型模式，共七种：行为型模式，共十一种：
Python实现PageRank算法
qq_42568323的博客
11-11 225
PageRank算法是由Google的创始人Larry Page和Sergey Brin提出的，用于评估网页的“重要性”。PageRank通过考虑网页的链接结构来确定一个网页的重要性，假设一个网页的重要性由指向它的网页数量和这些网页的重要性决定。每个网页有一个初始的“PageRank值”，通常设为相同。在每次迭代中，网页的PageRank值通过计算所有指向该网页的网页的PageRank值加权平均来更新。每个网页的PageRank值越高，表示它越重要。
【Rust设计模式之Fold模式】
m0_37719524的博客
11-08 501
如Rust Collection中的fold方法，是消耗迭代器适配器，将闭包应用于每一个元素，并将结果返回一样。Fold模式的中心思想也是如此，将元素折叠处理，最终计算出新的元素。而我们自己实现的Fold模式，一般用于映射数据结构，不同于面向对象的原地修改，由于Rust的引用和借用以及不可变性，生成新的结构从而替代老的结构调理更为清晰。总结：通常来说只有我们在自己编写一些数据结构的时候方才用得到这种fold模式，一般的业务逻辑相对的较少能够涉及到此，不过多懂一些也是极好的~“万全之计便是即刻行动”
程序代码设计模式之模板方法模式（1）
最新发布
门徒07的博客
11-12 79
今天我们将开始整理程序代码的设计模式，之前一直没有整理是因为网上讲的一大堆了，都烂大街了，现在又打算开始整理是因为设计模式要融入自己的程序代码里，不断的加深理解，去实践而不是只读读博文。在这个例子中，draw方法定义了视图绘制的基本步骤，而onDraw方法则留给子类去实现具体的绘制逻辑。这样做的好处是，draw方法为子类提供了一个清晰的绘制接口，同时保留了灵活性，允许子类根据需要自定义绘制过程。其主要特点是将一些步骤延迟到子类中，这些子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。
单例模式全面解析
hello.reader
11-12 331
单例模式（Singleton Pattern）是一种创建型设计模式，主要目的是确保一个类在系统中只有一个实例，并提供一个全局访问点供其他代码使用该实例。单例模式在许多场景中都有应用，例如数据库连接、日志管理、配置管理等场景都可能需要确保系统中仅存在一个实例。单例模式的关键要点唯一性：确保类在系统中只能存在一个实例，避免重复创建带来的资源浪费或潜在的逻辑错误。延迟初始化：通常，单例实例在首次被请求时创建，以延迟加载的方式提高系统的资源利用率。全局访问点。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值