目录
我们来学习单例模式与线程安全
线程安全和重⼊问题
线程安全：就是多个线程在访问共享资源时，能够正确地执⾏，不会相互⼲扰或破坏彼此的执⾏结 果。⼀般⽽⾔，多个线程并发同⼀段只有局部变量的代码时，不会出现不同的结果。但是对全局变量 或者静态变量进⾏操作，并且没有锁保护的情况下，容易出现该问题。
重⼊：同⼀个函数被不同的执⾏流调⽤，当前⼀个流程还没有执⾏完，就有其他的执⾏流再次进⼊， 我们称之为重⼊。⼀个函数在重⼊的情况下，运⾏结果不会出现任何不同或者任何问题，则该函数被 称为可重⼊函数，否则，是不可重⼊函数。
学到现在，其实我们已经能理解重⼊其实可以分为两种情况 ：多线程重⼊函数 和信号导致⼀个执⾏流重复进⼊函数
所以上面这些都可以不用看的，直接输出结论：
全局变量属于临界资源。
死锁和活锁
死锁
死锁是指在⼀组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所站⽤不会 释放的资源⽽处于的⼀种永久等待状态。
死锁是指两个或多个线程因为相互等待对方释放资源，导致它们永远无法继续执行的状态。
就是多个线程申请多个未释放的锁，然后他们各自却持有这些锁(未解锁)，导致都需要等待对方释放，比如A线程持有锁a，B线程持有锁b，那B今天来申请锁A，A申请锁b，这样A，B线程都需要各自等待对方释放才能申请成功，跟那个shared_ptr的循环引用无法释放一样的道理。
死锁 本质上就是多个线程交叉持有对方需要的资源，但又都不释放，导致所有线程都卡死在等待状态。
只有一个线程申请锁时也可能导致死锁的，自己重复申请自己上次没有释放的锁，怎么解决死锁问题，只能使用外部外部干预，要干预首先了解死锁四个必要条件。
死锁四个必要条件
互斥条件：⼀个资源每次只能被⼀个执⾏流使⽤，如果多个执行流可以访问同一个锁，怎么可能会死锁呢。破坏这个条件不太可能，违背锁的意愿。
请求与保持条件：⼀个执⾏流因请求资源⽽阻塞时，对已获得的资源保持不放。
不剥夺条件：⼀个执⾏流已获得的资源，在末使⽤完之前，不能强⾏剥夺，就是一个线程使用锁进入临界区访问具有原子性，还没访问完不能解锁。
循环等待条件：若⼲执⾏流之间形成⼀种头尾相接的循环等待资源的关系，导致死锁完全是在锁上等待导致的。打破这个简单呀，使用try_lock进行申请锁就可以了呀，锁不可用就返回false。
所以如何避免死锁就是破坏死锁的四个必要条件中的一个就可以了，破坏循环等待条件问题：资源⼀次性分配，使⽤超时机制、加锁顺序⼀致，也可以避免锁未释放的场景。
活锁
活锁是指多个线程不断地 相互让步，但因为策略问题，导致它们无法取得进展，活锁和死锁的区别就是线程不会一直等待一个没有解锁的锁，而是一直不断的申请，直至申请成功。相当于这些线程一直在申请结果没有成功，没有成功还一直在申请。
由于不停的申请锁会带来CPU的高占用，所以也是程序禁止的一种情况。
STL,智能指针和线程安全
STL中的容器不一定都是线程安全的，大部分函数都不支持重入所以都是线程不安全的，STL的设计初衷是将性能挖掘到极致，⽽⼀旦涉及到加锁保证线程安全，会对性能造成巨⼤的影 响。⽽且对于不同的容器，加锁⽅式的不同，性能可能也不同(例如hash表的锁表和锁桶)。因此STL默认不是线程安全，如果需要在多线程环境下使⽤，往往需要调⽤者⾃⾏保证线程安全。
智能指针是线程安全的，所以我们才愿意将一个线程交给他管理，对于unique_ptr，由于只是在当前代码块范围内⽣效，因此不涉及线程安全问题。
对于shared_ptr，多个对象需要共⽤⼀个引⽤计数变量，所以会存在线程安全问题。但是标准库实现的时 候考虑到了这个问题，基于原⼦操作(CAS)的⽅式保证shared_ptr能够⾼效，原⼦的操作引⽤计数。
但是智能指针指向的对象不一定是线程安全的，只是智能指针的操作的线程安全的。
线程安全的单例模式
某些类，只应该具有⼀个对象(实例)，就称之为单例。 例如⼀个男⼈只能有⼀个媳妇。 在很多服务器开发场景中，经常需要让服务器加载很多的数据(上百G)到内存中，此时往往要⽤⼀个单例 的类来管理这些数据。
单例模式主要分为饿汉模式和懒汉模式。要实现单例那这两种模式都是禁止拷贝的，而且初始化函数必须放为私有，不让外部直接通过构造函数访问。
饿汉模式
吃完饭, ⽴刻洗碗, 这种就是饿汉⽅式.，因为下⼀顿吃的时候可以⽴刻拿着碗就能吃饭。也就是饿汉模式里面肯定已经创建出了一个静态的对象，等你要调用的时候，通过一个static函数返回，保证返回函数，和创建的静态变量在类中只有一份，防止拷贝。
懒汉模式
吃完饭, 先把碗放下, 然后下⼀顿饭⽤到这个碗了再洗碗, 就是懒汉⽅式，就是需要时才创建对象的机制，属于延迟创建/加载，同样也只有一个对象，所以new出来的对象需要装在一个static指针里面，而这个指针是类里面已经创建好的。
反正需要时才调用getinstance创建，然后返回。存在⼀个严重的问题，线程不安全。 第⼀次调⽤GetInstance的时候，如果两个线程同时调⽤，可能会创建出两份T对象的实例， 但是后续再次调⽤，就没有问题了，此时inst就不是空了，不能创建对象了。
懒汉模式实现单例模式(线程安全版本)
cpp
#pragma once
#include<iostream>
using namespace std;
#include<memory>
#include<unistd.h>
#include<vector>
#include<string>
#include<queue>
#include<functional> //
#include"pthread.hpp"
#include"mutex.hpp"
#include"cond.hpp"
#include"log.hpp"
namespace threadpoolmodule
{
using namespace lockmodule;
using namespace threadmodule;
using namespace condmodule;
using namespace logmodule;
using thread_t = shared_ptr<thread>;
//用来做测试的线程方法
void defaulttest()
{
while (true)
{
LOG(loglevel::DEBUG) << "我是一个测试方法";
sleep(1);
}
}
const static int defaultnum = 5;
template<class T>
class threadpool
{
private:
bool isempty()
{
return _taskq.empty();
}
void HandleTask(string name)
{
LOG(loglevel::INFO) << "线程进入HandleTask的逻辑\n";
while (true)
{
T t;
{
lockguard lockguard(mut);
// 1.拿任务
while (isempty() && _isrunning)
{
_wait_num++;
_cond.wait(mut);
_wait_num--;
}
if (isempty() && !_isrunning)
{
break;
}
t = _taskq.front();
_taskq.pop();
}
//2 处理任务
t(name); //规定，未来所有的任务处理都是必须提供()直接调用的方法
}
LOG(loglevel::INFO) << "线程：" << name << "退出";
}
private:
threadpool()
: _num(defaultnum)
, _wait_num(0)
,_isrunning(false)
{
for (int i = 0; i < _num; i++)
{
//
_threads.push_back(make_shared<thread>(bind(&threadpool::HandleTask, this, placeholders::_1)));
LOG(loglevel::INFO) << "构键线程" << _threads.back()->getname() << "对象 。。。成功";
}
}
public:
threadpool<T>& operator=(const threadpool<T>&) = delete; //使用operator=的赋值拷贝不能用了
threadpool(const threadpool<T>&) = delete; //赋值拷贝不能用了
static threadpool<T>* getinstance()
{
LOG(loglevel::INFO) << "单例首次被执行，需要加载对象...";
if (instance == nullptr)
{
instance = new threadpool<T>();
}
return instance;
}
void start()
{
if (_isrunning)
{
return;
}
_isrunning = true;
for (auto& thread_ptr : _threads)
{
thread_ptr->start();
LOG(loglevel::INFO) << "启动线程" << thread_ptr->getname() << "。。。成功";
}
}
void equeue(T in)
{
lockguard lockguard(mut);
if (!_isrunning)
{
return;
}
_taskq.push(move(in));
if ( _wait_num)
{
_cond.notify();
}
}
void stop()
{
//让里面的线程都重新自己退出
//退出之前需要将所有的任务都处理完，所以需要一次性唤醒所有在等待的线程
if (_isrunning)
{
_isrunning = false;
if (_wait_num)
{
_cond.notifyall();
}
}
}
void join()
{
for (auto& thread_ptr : _threads)
{
thread_ptr->join();
LOG(loglevel::INFO) << "停止线程" << thread_ptr->getname() << "。。。成功";
}
}
~threadpool()
{}
private:
vector<thread_t> _threads; //线程池中的线程初始个数在数组里面
int _num; //线程池的容量
queue<T> _taskq; //线程池中的任务队列
mutex mut;
cond _cond;
int _wait_num; //等待队列线程
bool _isrunning;
static threadpool<T>* instance;
};
template<class T>
threadpool<T>* threadpool<T>::instance = nullptr; //在外面初始化, 私有的static成员可以在类外初始化
};
instance必须放私有，这样比较安全。
懒汉模型这种延迟生成，按需生成的技术在操作系统内核用的还是比较多的，像什么写时拷贝，malloc创建空间，物理地址的映射都是。
"不到万不得已，绝不提前分配"，这种按需分配的策略在操作系统内核中极为常见，既能提升性能，又能节省资源。
但是外面的getinstance方法还没有加锁保护，所以需要多增加一个锁进行保护。进入函数的时候立即加锁，加锁前需要先判断是否满足instance是空的，不然白加锁了，为什么使用双重判断呢，外层是为了防止白加锁，内层是为了防止加锁失败或者其他原因导致多个线程进来从而导致instance被赋值两次。
静态成员函数不能直接访问类的非静态成员变量，所以这个锁也应该是静态的才可以被访问到。
cpp
private:
vector<thread_t> _threads; //线程池中的线程初始个数在数组里面
int _num; //线程池的容量
queue<T> _taskq; //线程池中的任务队列
mutex mut;
static mutex _lock;
cond _cond;
int _wait_num; //等待队列线程
bool _isrunning;
static threadpool<T>* instance;
};
template<class T>
threadpool<T>* threadpool<T>::instance = nullptr; //在外面初始化, 私有的static成员可以在类外初始化
template<class T>
mutex threadpool<T>::_lock;
饿汉模式实现单例模式
cpp
#pragma once
#include<iostream>
using namespace std;
#include<memory>
#include<unistd.h>
#include<vector>
#include<string>
#include<queue>
#include<functional> //
#include"pthread.hpp"
#include"mutex.hpp"
#include"cond.hpp"
#include"log.hpp"
namespace threadpoolmodule
{
using namespace lockmodule;
using namespace threadmodule;
using namespace condmodule;
using namespace logmodule;
using thread_t = shared_ptr<thread>;
//用来做测试的线程方法
void defaulttest()
{
while (true)
{
LOG(loglevel::DEBUG) << "我是一个测试方法";
sleep(1);
}
}
const static int defaultnum = 5;
template<class T>
class threadpool
{
private:
bool isempty()
{
return _taskq.empty();
}
void HandleTask(string name)
{
LOG(loglevel::INFO) << "线程进入HandleTask的逻辑\n";
while (true)
{
T t;
{
lockguard lockguard(mut);
// 1.拿任务
while (isempty() && _isrunning)
{
_wait_num++;
_cond.wait(mut);
_wait_num--;
}
if (isempty() && !_isrunning)
{
break;
}
t = _taskq.front();
_taskq.pop();
}
//2 处理任务
t(name); //规定，未来所有的任务处理都是必须提供()直接调用的方法
}
LOG(loglevel::INFO) << "线程：" << name << "退出";
}
private:
threadpool()
: _num(defaultnum)
, _wait_num(0)
,_isrunning(false)
{
for (int i = 0; i < _num; i++)
{
//
_threads.push_back(make_shared<thread>(bind(&threadpool::HandleTask, this, placeholders::_1)));
LOG(loglevel::INFO) << "构键线程" << _threads.back()->getname() << "对象 。。。成功";
}
}
public:
threadpool<T>& operator=(const threadpool<T>&) = delete; //使用operator=的赋值拷贝不能用了
threadpool(const threadpool<T>&) = delete; //赋值拷贝不能用了
static threadpool<T>* getinstance()
{
LOG(loglevel::INFO) << "单例首次被执行，需要加载对象...";
return &instance;
}
void start()
{
if (_isrunning)
{
return;
}
_isrunning = true;
for (auto& thread_ptr : _threads)
{
thread_ptr->start();
LOG(loglevel::INFO) << "启动线程" << thread_ptr->getname() << "。。。成功";
}
}
void equeue(T in)
{
lockguard lockguard(mut);
if (!_isrunning)
{
return;
}
_taskq.push(move(in));
if ( _wait_num)
{
_cond.notify();
}
}
void stop()
{
//让里面的线程都重新自己退出
//退出之前需要将所有的任务都处理完，所以需要一次性唤醒所有在等待的线程
if (_isrunning)
{
_isrunning = false;
if (_wait_num)
{
_cond.notifyall();
}
}
}
void join()
{
for (auto& thread_ptr : _threads)
{
thread_ptr->join();
LOG(loglevel::INFO) << "停止线程" << thread_ptr->getname() << "。。。成功";
}
}
~threadpool()
{}
private:
vector<thread_t> _threads; //线程池中的线程初始个数在数组里面
int _num; //线程池的容量
queue<T> _taskq; //线程池中的任务队列
mutex mut;
cond _cond;
int _wait_num; //等待队列线程
bool _isrunning;
static threadpool<T> instance;
};
template<class T>
threadpool<T> threadpool<T>::instance; //在外面初始化, 私有的static成员可以在类外初始化
};这个实现起来差不多呀，而且完全没有线程安全问题，因为就一个对象。
