网站上内容列表怎么做,网站建设服务代理商,如何做网络免费推广方案,成全视频免费观看在线看第7季目录
线程安全和重⼊问题
死锁和活锁
死锁
死锁四个必要条件
活锁
STL,智能指针和线程安全
线程安全的单例模式
饿汉模式
懒汉模式
懒汉模式实现单例模式(线程安全版本)
饿汉模式实现单例模式 我们来学习单例模式与线程安全
线程安全和重⼊问题
线程安全#xff…目录
线程安全和重⼊问题
死锁和活锁
死锁
死锁四个必要条件
活锁
STL,智能指针和线程安全
线程安全的单例模式
饿汉模式
懒汉模式
懒汉模式实现单例模式(线程安全版本)
饿汉模式实现单例模式 我们来学习单例模式与线程安全
线程安全和重⼊问题
线程安全就是多个线程在访问共享资源时能够正确地执⾏不会相互⼲扰或破坏彼此的执⾏结 果。⼀般⽽⾔多个线程并发同⼀段只有局部变量的代码时不会出现不同的结果。但是对全局变量 或者静态变量进⾏操作并且没有锁保护的情况下容易出现该问题。
重⼊同⼀个函数被不同的执⾏流调⽤当前⼀个流程还没有执⾏完就有其他的执⾏流再次进⼊ 我们称之为重⼊。⼀个函数在重⼊的情况下运⾏结果不会出现任何不同或者任何问题则该函数被 称为可重⼊函数否则是不可重⼊函数。
学到现在其实我们已经能理解重⼊其实可以分为两种情况 多线程重⼊函数 和信号导致⼀个执⾏流重复进⼊函数 所以上面这些都可以不用看的直接输出结论 全局变量属于临界资源。 死锁和活锁
死锁
死锁是指在⼀组进程中的各个进程均占有不会释放的资源但因互相申请被其他进程所站⽤不会 释放的资源⽽处于的⼀种永久等待状态。
死锁是指两个或多个线程因为相互等待对方释放资源导致它们永远无法继续执行的状态。
就是多个线程申请多个未释放的锁然后他们各自却持有这些锁(未解锁)导致都需要等待对方释放比如A线程持有锁aB线程持有锁b那B今天来申请锁AA申请锁b这样AB线程都需要各自等待对方释放才能申请成功跟那个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就不是空了不能创建对象了。 懒汉模式实现单例模式(线程安全版本)
#pragma once
#includeiostream
using namespace std;
#includememory
#includeunistd.h
#includevector
#includestring
#includequeue
#includefunctional //
#includepthread.hpp
#includemutex.hpp
#includecond.hpp
#includelog.hppnamespace threadpoolmodule
{using namespace lockmodule;using namespace threadmodule;using namespace condmodule;using namespace logmodule;using thread_t shared_ptrthread;//用来做测试的线程方法void defaulttest(){while (true){LOG(loglevel::DEBUG) 我是一个测试方法;sleep(1);}}const static int defaultnum 5;templateclass Tclass 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_sharedthread(bind(threadpool::HandleTask, this, placeholders::_1)));LOG(loglevel::INFO) 构键线程 _threads.back()-getname() 对象 。。。成功;}}public:threadpoolT operator(const threadpoolT) delete; //使用operator的赋值拷贝不能用了threadpool(const threadpoolT) delete; //赋值拷贝不能用了static threadpoolT* getinstance(){LOG(loglevel::INFO) 单例首次被执行需要加载对象...;if (instance nullptr){instance new threadpoolT();}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:vectorthread_t _threads; //线程池中的线程初始个数在数组里面int _num; //线程池的容量queueT _taskq; //线程池中的任务队列mutex mut;cond _cond;int _wait_num; //等待队列线程bool _isrunning;static threadpoolT* instance;};templateclass TthreadpoolT* threadpoolT::instance nullptr; //在外面初始化, 私有的static成员可以在类外初始化
};instance必须放私有这样比较安全。 懒汉模型这种延迟生成按需生成的技术在操作系统内核用的还是比较多的像什么写时拷贝malloc创建空间物理地址的映射都是。
“不到万不得已绝不提前分配”这种按需分配的策略在操作系统内核中极为常见既能提升性能又能节省资源。
但是外面的getinstance方法还没有加锁保护所以需要多增加一个锁进行保护。进入函数的时候立即加锁加锁前需要先判断是否满足instance是空的不然白加锁了为什么使用双重判断呢外层是为了防止白加锁内层是为了防止加锁失败或者其他原因导致多个线程进来从而导致instance被赋值两次。
静态成员函数不能直接访问类的非静态成员变量所以这个锁也应该是静态的才可以被访问到。 private:vectorthread_t _threads; //线程池中的线程初始个数在数组里面int _num; //线程池的容量queueT _taskq; //线程池中的任务队列mutex mut;static mutex _lock;cond _cond;int _wait_num; //等待队列线程bool _isrunning;static threadpoolT* instance;};templateclass TthreadpoolT* threadpoolT::instance nullptr; //在外面初始化, 私有的static成员可以在类外初始化templateclass Tmutex threadpoolT::_lock; 饿汉模式实现单例模式
#pragma once
#includeiostream
using namespace std;
#includememory
#includeunistd.h
#includevector
#includestring
#includequeue
#includefunctional //
#includepthread.hpp
#includemutex.hpp
#includecond.hpp
#includelog.hppnamespace threadpoolmodule
{using namespace lockmodule;using namespace threadmodule;using namespace condmodule;using namespace logmodule;using thread_t shared_ptrthread;//用来做测试的线程方法void defaulttest(){while (true){LOG(loglevel::DEBUG) 我是一个测试方法;sleep(1);}}const static int defaultnum 5;templateclass Tclass 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_sharedthread(bind(threadpool::HandleTask, this, placeholders::_1)));LOG(loglevel::INFO) 构键线程 _threads.back()-getname() 对象 。。。成功;}}public:threadpoolT operator(const threadpoolT) delete; //使用operator的赋值拷贝不能用了threadpool(const threadpoolT) delete; //赋值拷贝不能用了static threadpoolT* 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:vectorthread_t _threads; //线程池中的线程初始个数在数组里面int _num; //线程池的容量queueT _taskq; //线程池中的任务队列mutex mut;cond _cond;int _wait_num; //等待队列线程bool _isrunning;static threadpoolT instance;};templateclass TthreadpoolT threadpoolT::instance; //在外面初始化, 私有的static成员可以在类外初始化
};
这个实现起来差不多呀而且完全没有线程安全问题因为就一个对象。
