曾经参与过的一款网络游戏，其服务器使用了异常复杂的多线程序解决方案。导致应用层程序员编写的代码很容易就出现死锁。
最终，公司的一个老员工，只能开发了一个死锁检测框架，在debug模式下运行时，只要发生死锁就会打印出调用堆栈。
虽然说这个框架基本可以在上线前把所有的死锁都检测了出来，但是，规根到底这是设计不合理造成的，多线程利用好了会提升
应用的效率，用不好的话，除了影响效率外，对上层开发简直是灾难。
下面说说那个检测方法，其实方法挺简单的。
有两个容器，一个用于保存线程正在请求的锁，一个用于保存线程已经持有的锁。每次加锁之前都会做如下检测:
1)检测当前正在请求的锁是否已经被其它线程持有,如果有，则把那些线程找出来
2)遍历第一步中返回的线程，检查自己持有的锁是否正被其中任何一个线程请求
如果第二步返回真,表示出现了死锁
下面是简单的实现:
appMutex.h
#ifndef _APPMUTEX_H
#define _APPMUTEX_H
#include <iostream>
#include "lock.h"
#include <map>
#include <list>
class appMutex;
static Lock gMtx;
//记录了线程当前正在请求的锁
class mtxReqMgr
{
public:
static bool check(pthread_t pid);
static void reqMutex(appMutex *mtx);
static void clearReq(appMutex *mtx);
private:
static std::map<pthread_t,appMutex*> reqMap;//每个线程只可能请求一个锁
};
//记录了线程已经持有的锁
class mtxHoldMgr
{
public:
static bool check(pthread_t pid,appMutex *mtx);
static bool check(appMutex *mtx,std::list<pthread_t> &ret);
static void hold(appMutex *mtx);
static void release(appMutex *mtx);
//释放掉所有已经持有的锁
static void releaseAll();
private:
static std::map<pthread_t,std::list<appMutex*> > holdMap;//每个线程可能拥有好几个锁
};
class appMutex : private Lock
{
friend class mtxHoldMgr;
public:
appMutex(const char *name):name(name)
{}
void lock()
{
/*这里执行死锁检测，检测规则
1)检测当前正在请求的锁是否已经被其它线程持有,如果有，则把那些线程找出来
2)遍历第一步中返回的线程，检查自己持有的锁是否正被其中任何一个线程请求
如果第二步返回真,表示出现了死锁
*/
std::list<pthread_t> mtxHolds;
if(mtxHoldMgr::check(this,mtxHolds))
{
std::list<pthread_t>::iterator it = mtxHolds.begin();
std::list<pthread_t>::iterator end = mtxHolds.end();
for( ; it != end; ++it)
{
if(mtxReqMgr::check(*it))
{
mtxHoldMgr::releaseAll();
printf("dead lock in require %s,thread:%u/n",name.c_str(),pthread_self());
exit(0);
}
}
}
mtxReqMgr::reqMutex(this);
Lock::lock();
mtxReqMgr::clearReq(this);
mtxHoldMgr::hold(this);
}
void unlock()
{
Lock::unlock();
mtxHoldMgr::release(this);
}
private:
void release()//只有在出现死锁时才会调用
{
Lock::unlock();
}
private:
std::string name;
};
#endif
appMutex.cpp
#include "appMutex.h"
std::map<pthread_t,appMutex*> mtxReqMgr::reqMap;
std::map<pthread_t,std::list<appMutex*> > mtxHoldMgr::holdMap;
//释放掉所有已经持有的锁
void mtxHoldMgr::releaseAll()
{
Scope_lock _guard(gMtx);
pthread_t pid = pthread_self();
std::map<pthread_t,std::list<appMutex*> >::iterator it = holdMap.find(pid);
if(it != holdMap.end())
{
while(!it->second.empty())
{
appMutex *_appmtx = it->second.back();
it->second.pop_back();
_appmtx->release();
}
}
}
bool mtxReqMgr::check(pthread_t pid)
{
Scope_lock _guard(gMtx);
pthread_t selfpid = pthread_self();
std::map<pthread_t,appMutex*>::iterator it = reqMap.find(pid);
if(it != reqMap.end() && it->second != NULL)
{
return mtxHoldMgr::check(selfpid,it->second);
}
return false;
}
void mtxReqMgr::reqMutex(appMutex *mtx)
{
Scope_lock _guard(gMtx);
pthread_t pid = pthread_self();
std::map<pthread_t,appMutex*>::iterator it = reqMap.find(pid);
if(it == reqMap.end())
{
reqMap.insert(std::make_pair(pid,mtx));
}
else
{
it->second = mtx;
}
}
void mtxReqMgr::clearReq(appMutex *mtx)
{
Scope_lock _guard(gMtx);
pthread_t pid = pthread_self();
std::map<pthread_t,appMutex*>::iterator it = reqMap.find(pid);
if(it != reqMap.end())
it->second = NULL;
else
{
printf("it must be error %s %d /n",__FILE__,__LINE__);
}
}
bool mtxHoldMgr::check(pthread_t pid,appMutex *mtx)
{
Scope_lock _guard(gMtx);
std::map<pthread_t,std::list<appMutex*> >::iterator it = holdMap.find(pid);
if(it != holdMap.end())
{
std::list<appMutex*>::iterator lit = it->second.begin();
std::list<appMutex*>::iterator lend = it->second.end();
for( ; lit != lend; ++lit)
{
if(mtx == *lit)
{
return true;
}
}
}
return false;
}
bool mtxHoldMgr::check(appMutex *mtx,std::list<pthread_t> &ret)
{
Scope_lock _guard(gMtx);
pthread_t pid = pthread_self();
std::map<pthread_t,std::list<appMutex*> >::iterator it = holdMap.begin();
std::map<pthread_t,std::list<appMutex*> >::iterator end = holdMap.end();
for( ; it != end; ++it)
{
if(it->first == pid)
continue;
std::list<appMutex*>::iterator lit = it->second.begin();
std::list<appMutex*>::iterator lend = it->second.end();
for( ; lit != lend; ++lit)
{
if(mtx == *lit)
{
ret.push_back(it->first);
break;
}
}
}
return !ret.empty();
}
void mtxHoldMgr::hold(appMutex *mtx)
{
Scope_lock _guard(gMtx);
pthread_t pid = pthread_self();
std::map<pthread_t,std::list<appMutex*> >::iterator it = holdMap.find(pid);
if(it == holdMap.end())
{
std::list<appMutex*> tmp;
tmp.push_back(mtx);
holdMap.insert(std::make_pair(pid,tmp));
}
else
{
it->second.push_back(mtx);
}
}
void mtxHoldMgr::release(appMutex *mtx)
{
Scope_lock _guard(gMtx);
pthread_t pid = pthread_self();
std::map<pthread_t,std::list<appMutex*> >::iterator it = holdMap.find(pid);
if(it != holdMap.end())
{
if(mtx != it->second.back())
{
//释放锁的顺序跟加锁的顺序不一致
printf("it must be error %s %d /n",__FILE__,__LINE__);
}
else
it->second.pop_back();
}
else
printf("it must be error %s %d /n",__FILE__,__LINE__);
}
在两个线程中分别如下调用，就会看到死锁警告了
appMutex a("a");
appMutex b("b");
threada:
while(1)
{
a.lock();
Thread::sleep(1);
b.lock();
b.unlock();
a.unlock();
}
threadb:
while(1)
{
b.lock();
a.lock();
a.unlock();
b.unlock();
}