C++并发实战8：deadlock
来源：互联网 发布：最新手机看电视软件 编辑：程序博客网 时间：2024/06/05 00:43
1 死锁：每个线程都希望锁住一些列锁以执行某个操作，且每个线程持有一个不同的锁，最终每个线程都需要其它线程的锁，导致所有线程都不能向前执行。
1.1 顺序加锁lock
1.1 死锁的一个解决方式：每个线程对锁的请求顺序一致。C++库提供了顺序加锁机制，可以一次性锁住多个mutex而不会出现死锁：
void lock (Mutex1& a, Mutex2& b, Mutexes&... cde);对a,b...cde锁顺序加锁，若在加锁过程中抛出任何异常就释放前面已持有的锁。不会出现死锁，一个例子如下：
#include <mutex>#include<unistd.h>#include<thread>#include<iostream>using namespace std;class big_object{ public: big_object(int i=0):data(i){} public: int data;};void swap(big_object& lhs,big_object& rhs){ sleep(1); cout<<"swap()"<<endl;}class X{ private: big_object some_detail; mutable std::mutex m; public: X(big_object const& sd):some_detail(sd){} friend void swap(X& lhs, X& rhs) { if(&lhs==&rhs) return; std::lock(lhs.m,rhs.m);//C++库会自动生成加锁顺序，即使调用顺序不一致 std::lock_guard<std::mutex> lock_a(lhs.m,std::adopt_lock);//adopt_lock是告诉lock_guard对象mutex已经被上锁，而lock_gurad对象将获得mutex的所有权，这样就可以保证在lock可能出现异常导致没有unlock的情形不会出现，栈对象会在异常抛出后自动析构 std::lock_guard<std::mutex> lock_b(rhs.m,std::adopt_lock); swap(lhs.some_detail,rhs.some_detail); }};void threadFun(X& one,X& two){ swap(one,two);}int main(){ big_object ten(10),hundred(100); X one(ten),two(hundred); thread threadOne(threadFun,ref(one),ref(two));//不同线程有不同的参数调用顺序 thread threadTwo(threadFun,ref(two),ref(one)); threadOne.join(); threadTwo.join(); return 0;}程序输出：
swap()
swap()
1.2 可以通过比较多个mutex的地址大小实现顺序加锁，下面的程序是先锁地址小的mutex，再锁地址大的mutex。
#include<iostream>#include<mutex>#include<unistd.h>#include<thread>#include<functional>using namespace std;class test{ public: friend void orderLock(test& one,test& two){ if(&one.m>&two.m){ lock_guard<mutex> smallGuard(two.m); sleep(1); cout<<"the second argument's mutex smaller"<<endl; lock_guard<mutex> bigGuard(one.m); } else if(&one.m==&two.m) cout<<"lock the same mutex"<<endl; else{ lock_guard<mutex> smallGuard(one.m); sleep(1); cout<<"the first argument's mutex smaller"<<endl; lock_guard<mutex> bigGuard(two.m); } } private: mutex m;};//void threadFun(test& one,test& two){//#2#// orderLock(one,two);// cout<<&one<<" "<<&two<<" lock success"<<endl;//}int main(){ test one,two; cout<<&one<<" "<<&two<<endl; orderLock(one,two);//#1# orderLock(two,one);//#1# //thread threadOne(threadFun,ref(one),ref(two));//#2# 注意这里要用ref将test对象转换为引用传递到子线程中去，否则thread会拷贝test对象从而拷贝mutex，而mutex::mutex(const mutex&)=delete从而会报错 //thread threadTwo(threadFun,ref(two),ref(one));//#2# //threadOne.join(); //threadTwo.join();//这里要说明的是多线程间共享锁不是什么好事情 return 0;}注释掉#1#,采用#2#多线程模拟，程序输出：多线程下证地址小的mutex先上锁的加锁顺序
the first argument's mutex smaller //orderLock(one,two)先锁one
the second argument's mutex smaller //orderLock(two,one)先锁one
0x7fffa4791500 0x7fffa4791530
the first argument's mutex smaller
0x7fffa4791500 0x7fffa4791530 lock success
the second argument's mutex smaller
0x7fffa4791530 0x7fffa4791500 lock success
0x7fffae7c2940 0x7fffae7c2970
也是保
2 避免死锁
死锁不仅仅发生在mutex上，如多个线程相互之间调用join也会死锁。避免死锁的方式：don’t wait for another thread if there’s a chance it’s waiting for you//不要等待那些有机会等待你的线程。
2.1 避免使用递归锁，don’t acquire a lock if you already hold one。
2.2 避免持有锁期间执行用户代码，不清楚用户代码将会做什么就有可能出现死锁。有时这种情形难以避免的，如std::stack是个泛型类，内部存储用户指定的数据类型，stack<vector<string> >之类的vector本身就具有很多操作，更别说stack存储用户自定义的类万一又想存取stack本身呢？这种情形可以强加一些限制条件以保证加锁安全。
2.3 若果一定要使用两个及以上的加锁，一定要确保加锁顺序，std::lock是个不错的选择。例如一个双向链表若一个线程从头开始遍历，一个线程从尾开始遍历那么两个线程必然会在中间某处出现死锁，这时放弃双向遍历而规定一个加锁顺序。
2.4 lock hierarchy: 通常对对个mutex加锁会导致死锁，解决这个问题的最好办法就是保证加锁的顺序，当lock总是以一个规定的顺序进行时不会出现死锁。lock hierarchy指的是给每个mutex分配一个标号从而对mutex逻辑排序。限制条件是：当线程已经持有编号比n小的锁时不能再请求标号为n的mutex.
#include <mutex>#include <stdexcept>class hierarchical_mutex//可用于lock_guard<hierarchical_mutex>{ std::mutex internal_mutex;// unsigned long const hierarchy_value;//mutex所在的层次 unsigned long previous_hierarchy_value;//记录前一个mutex的层次，用于解锁时恢复线程的层次 static thread_local unsigned long this_thread_hierarchy_value;//线程所在的层次，是个线程私有数据 void check_for_hierarchy_violation()//检查当前mutex是否小于线程层次，不是则抛出异常 { if(this_thread_hierarchy_value <= hierarchy_value) { throw std::logic_error("mutex hierarchy violated"); } } void update_hierarchy_value()//更新线程的层次 { previous_hierarchy_value=this_thread_hierarchy_value;//通过previous_hierarchy_value记住线程的层次 this_thread_hierarchy_value=hierarchy_value;//用当前mutex的层次更新线程层次 }public: explicit hierarchical_mutex(unsigned long value): hierarchy_value(value),//mutex层次初始值 previous_hierarchy_value(0) {} void lock()//对mutex加锁 { check_for_hierarchy_violation();//先检查，保证mutex层次小于线程层次 internal_mutex.lock(); update_hierarchy_value();//更新线程层次 } void unlock()//对mutex解锁 { this_thread_hierarchy_value=previous_hierarchy_value;//用记录的previous_hierarchy_value恢复线程层次 internal_mutex.unlock(); } bool try_lock()//尝试加锁，若mutex已被其它上锁则返回false { check_for_hierarchy_violation(); if(!internal_mutex.try_lock()) return false; update_hierarchy_value(); return true; }};thread_local unsigned long hierarchical_mutex::this_thread_hierarchy_value(ULONG_MAX);//线程层次初始值为最大，保证开始可以对任意mutex上锁 0 0
- C++并发实战8：deadlock
- Chapter 8 Deadlock
- Deadlock
- deadlock
- Deadlock
- Deadlock
- DeadLock
- DeadLock
- Deadlock
- deadLock
- （十五）java并发编程--线程的死锁(deadlock)
- 【Java并发编程实战】—–“J.U.C”：Condition
- 【Java并发编程实战】—–“J.U.C”：Semaphore
- 【Java并发编程实战】—–“J.U.C”：ReentrantReadWriteLock
- 【Java并发编程实战】-----“J.U.C”：CyclicBarrier
- 【Java并发编程实战】—–“J.U.C”：CyclicBarrier
- 【Java并发编程实战】—–“J.U.C”：CountDownlatch
- 【Java并发编程实战】—–“J.U.C”：Phaser
- JavaScript HTML DOM - 改变 HTML
- php发送邮件附带附件
- 待我长发及腰原文
- Hadoop启动不了Namenode进程，出现IllegalArgumentException异常
- JSONP跨域的原理解析
- C++并发实战8：deadlock
- 用例图
- 第十一章 类的无参方法 简答题3 计算器
- Oracle Database Client 11gR2 精简版 发布
- showModalDialog以及open用法简介
- Intelij Idea 快捷键
- 用 Windows XP 的两个强有力的工具在您的代码中检测并堵塞 GDI 泄漏
- django的HTTPREQUEST对象
- 加载地址、运行地址
