设计模式-单例模式

最新推荐文章于 2024-09-04 16:50:07 发布

yergen

最新推荐文章于 2024-09-04 16:50:07 发布

阅读量248

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/m0_37715028/article/details/124973294

版权

设计模式专栏收录该内容

2 篇文章 1 订阅

订阅专栏

1. 什么是单例模式？

单例模式是指在整个系统生命周期里，保证一个类只能产生一个实例，确保该类的唯一性。

单例模式分类

单例模式可以分为懒汉式和饿汉式，两者之间的区别在创建实例的时间不同。

懒汉式：指系统运行中，实例并不存在，只有当需要使用该实例时，才会去创建并使用实例。（这种方式要考虑线程安全）

饿汉式：指系统一运行，就初始化创建实例，当需要时，直接调用即可。（本身就线程安全，没有多线程的问题）

单例类的特点

构造函数和析构函数为private类型，目的禁止外部构造和析构。
拷贝构造和赋值构造函数为private类型，目的是禁止外部拷贝和赋值，确保实例的唯一性。
类里有个获取实例的静态函数，可以全局访问。

01 普通懒汉式单例（线程不安全）

#include <iostream>
#include <mutex>
#include <pthread.h>

/* 普通懒汉式实现--线程不安全 */
class SingleInstance
{
public:
	//获取单例对象
	static SingleInstance* GetInstance();
	//释放单例，进程退出时调用
	static void deleteInstance();

	//打印单例地址
	void Print();
private:
	//将其构造函数和析构函数成为私有的，禁止外部构造和析构
	SingleInstance();
	~SingleInstance();
	//将其拷贝构造和赋值构造成为私有函数，禁止外部拷贝和赋值
	SingleInstance(const SingleInstance& signal);
	const SingleInstance& operator=(const SingleInstance& signal);
private:
	//唯一单例对象指针
	static SingleInstance* m_SingleInstance;
};
//初始化静态成员变量
SingleInstance* SingleInstance::m_SingleInstance = NULL;

SingleInstance* SingleInstance::GetInstance()
{
	if (m_SingleInstance == NULL)
	{
		//没有加锁是线程不安全的，当线程并发时会创建多个实例
		m_SingleInstance = new (std::nothrow)SingleInstance;
	}
	return m_SingleInstance;
}

void  SingleInstance::deleteInstance()
{
	if (m_SingleInstance)
	{
		delete m_SingleInstance;
		m_SingleInstance = NULL;
	}
}

void  SingleInstance::Print()
{
	std::cout << "我的实例内存地址是：" << this << std::endl;
}

SingleInstance::SingleInstance()
{
	std::cout << "构造函数 " << std::endl;
}


SingleInstance::~SingleInstance()
{
	std::cout << "析构函数 " << std::endl;
}

// 线程函数
void* PrintHello(void* threadid)
{
	//主线程和子线程分离，两者相互不干涉，子线程结束同时子线程的资源自动回收
	pthread_detach(pthread_self());

	//对传入的参数进行强制类型转换，由无类型指针变位整形数指针，然后再读取
	int tid = *((int*)threadid);

	std::cout << "Hi, 我是线程 ID：[" << tid << "]" << std::endl;

	//打印实例地址
	SingleInstance::GetInstance()->Print();

	pthread_exit(NULL);

	return 0;
}

const int NUM_THREADS = 5; //线程个数

int main(void)
{
	pthread_t threads[NUM_THREADS] = { 0 };
	int indexes[NUM_THREADS] = { 0 };  //用数组来保存i的值

	int ret = 0;
	int i = 0;

	std::cout << "main() : 开始 ... " << std::endl;

	for (i = 0; i < NUM_THREADS; i++)
	{
		std::cout << "main() : 创建线程：[" << i << "]" << std::endl;
		indexes[i] = i; //先保存i的值

		//传入的时候必须强制转换为void* 类型，即无类型指针
		ret = pthread_create(&threads[i], NULL, PrintHello, (void*)&(indexes[i]));
		if (ret)
		{
			std::cout << "Error:无法创建线程， " << ret << std::endl;
			exit(-1);
		}
	}

	//手动释放单实例的资源
	SingleInstance::deleteInstance();
	std::cout << "main() : 结束！" << std::endl;

	return 0;
}

注：如果遇到pthread.h多线程库问题，参考链接https://www.cnblogs.com/chenjx85/p/10574752.html

运行结果：

从运行结果可知，单例构造函数创建了两个，内存地址分别是0x01025828和0x010257c8,所以普通懒汉式单例只适合单进程不适合多进程，因为是线程不安全的。

2. 什么是线程安全，该如何保证线程安全？

在拥有共享数据和多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

为了保证线程安全可以：1、给共享的资源加把锁，保证每个资源变量每时每刻至多被一个线程占用。2、让线程也拥有资源，不用去共享进程中的资源。如：使用threadlocal可以为每个线程的维护一个私有的本地变量。

02 加锁的懒汉式单例（线程安全）

class SingleInstance
{
public:
	//获取单例对象
	static SingleInstance* GetInstance();
	//释放单例，进程退出时调用
	static void deleteInstance();

	//打印单例地址
	void Print();
private:
	//将其构造函数和析构函数成为私有的，禁止外部构造和析构
	SingleInstance();
	~SingleInstance();
	//将其拷贝构造和赋值构造成为私有函数，禁止外部拷贝和赋值
	SingleInstance(const SingleInstance& signal);
	const SingleInstance& operator=(const SingleInstance& signal);
private:
	//唯一单例对象指针
	static SingleInstance* m_SingleInstance;
	static std::mutex m_Mutex;
};
//初始化静态成员变量
SingleInstance* SingleInstance::m_SingleInstance = NULL;
std::mutex SingleInstance::m_Mutex;

SingleInstance* SingleInstance::GetInstance()
{
	//这里使用了俩个if判断语句的技术称为双检锁；好处是，只有判断指针为空的时候才加锁，
	//避免每次调用GetInstance的方法都加锁，锁的开销毕竟还是有点大。
	if (m_SingleInstance == NULL)
	{
		std::unique_lock<std::mutex> lock(m_Mutex); //加锁
		if (m_SingleInstance == NULL)
			m_SingleInstance = new (std::nothrow) SingleInstance;
	}

	return m_SingleInstance;
}

void  SingleInstance::deleteInstance()
{
	std::unique_lock<std::mutex> lock(m_Mutex); //加锁

	if (m_SingleInstance)
	{
		delete m_SingleInstance;
		m_SingleInstance = NULL;
	}
}

void  SingleInstance::Print()
{
	std::cout << "我的实例内存地址是：" << this << std::endl;
}

SingleInstance::SingleInstance()
{
	std::cout << "构造函数 " << std::endl;
}


SingleInstance::~SingleInstance()
{
	std::cout << "析构函数 " << std::endl;
}

运行结果：

从运行结果可以知，只创建了一个实例，内存地址为0x008557C8，但我实际的运行结果是两次构造函数，不清楚怎么回事。

03 内部静态变量的懒汉单例（c++ 11 线程安全）

///  内部静态变量的懒汉实现  //
class Single
{

public:
    // 获取单实例对象
    static Single &GetInstance();
	
	// 打印实例地址
    void Print();

private:
    // 禁止外部构造
    Single();

    // 禁止外部析构
    ~Single();

    // 禁止外部复制构造
    Single(const Single &signal);

    // 禁止外部赋值操作
    const Single &operator=(const Single &signal);
};

Single &Single::GetInstance()
{
    // 局部静态特性的方式实现单实例
    static Single signal;
    return signal;
}

void Single::Print()
{
	std::cout << "我的实例内存地址是:" << this << std::endl;
}

Single::Single()
{
    std::cout << "构造函数" << std::endl;
}

Single::~Single()
{
    std::cout << "析构函数" << std::endl;
}
///  内部静态变量的懒汉实现  //

04 饿汉式单例（本身就线程安全）

// 饿汉实现 /
class Singleton
{
public:
    // 获取单实例
    static Singleton* GetInstance();

    // 释放单实例，进程退出时调用
    static void deleteInstance();
    
    // 打印实例地址
    void Print();

private:
    // 将其构造和析构成为私有的, 禁止外部构造和析构
    Singleton();
    ~Singleton();

    // 将其拷贝构造和赋值构造成为私有函数, 禁止外部拷贝和赋值
    Singleton(const Singleton &signal);
    const Singleton &operator=(const Singleton &signal);

private:
    // 唯一单实例对象指针
    static Singleton *g_pSingleton;
};

// 代码一运行就初始化创建实例 ，本身就线程安全
Singleton* Singleton::g_pSingleton = new (std::nothrow) Singleton;

Singleton* Singleton::GetInstance()
{
    return g_pSingleton;
}

void Singleton::deleteInstance()
{
    if (g_pSingleton)
    {
        delete g_pSingleton;
        g_pSingleton = NULL;
    }
}

void Singleton::Print()
{
    std::cout << "我的实例内存地址是:" << this << std::endl;
}

Singleton::Singleton()
{
    std::cout << "构造函数" << std::endl;
}

Singleton::~Singleton()
{
    std::cout << "析构函数" << std::endl;
}
// 饿汉实现 /