0、互斥量
Windows下的互斥量
是个内核对象，每次WaitForSingleObject和ReleaseMutex时都会检查当前线程ID和占有互斥量的线程ID是否一致。
当多次Wait**时就要对应多次ReleaseMutex， 当ReleaseMutex过多次数时如果发现当前占有互斥量的线程ID和当前调用ReleaseMutex的线程ID不一致时仅仅返回FLASE，GetLastError返回ERROR_NOT_OWNER，没有其他副作用。
当占有mutex的线程在Release之前退出时，该mutex被【遗弃】，此时系统自动收回mutex，可供其他线程申请。
允许多次等待
WaitForSingleObject(hMutex, time);
WaitForSingleObject(hMutex, itme);
多次等待 对应多次释放
ReleaseMutex(hMutex);
ReleaseMutex(hMutex);
Linux下的互斥量
可以设置互斥量的属性是否为可以被同一个线程多次lock， 还可以设置该互斥量的范围，即是用于进程之间同步 还是 同一进程不同线程之间的同步。
相关API 将说明见代码注释部分。
1、相关API
//Initialize a mutex with attribute(can be NULL)
int pthread_mutex_init(
pthread_mutex_t* mutex,
const pthread_mutexattr_t* mutexattr);
//lock a mutex
int pthread_mutex_lock(pthread_mutex_t* mutex);
//ulock a mutex
int pthread_mutex_unlock(pthread_mutex_t* mutex);
//destroy a mutex
int pthread_mutex_destroy(pthread_mutex_t* mutex);
int pthread_mutexattr_setpshared(
pthread_mutexattr_t* mattr,
int pshared //PTHREAD_PROCESS_SHARE | PTHREAD_PROCESS_PRIVATE
);
int pthread_mutexattr_getshared(
pthread_mutexattr_t* mattr,
int* pshared);
int pthread_mutexattr_settype(
pthread_mutexattr_t* attr,
int type //PTHREAD_MUTEX_TIMED_NP -- default value
//PTHREAD_MUTEX_RECURISIVE_NP -- allow a thread lock multitimes
//PTHREAD_MUTEX_ERRORCHECK_NO -- check error lock, return EDEADLK if the same thread want to LOCK
//PTHREAD_MUTEX_ADAPTIVE_NO -- adaptive lock, the simplest lock
)
int pthread_mutexattr_gettype(
pthread_mutexattr_t* attr,
int* type
)
2、demo
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <errno.h>
using namespace std;
/***********************************************
*
* Initialize a mutex with attribute(can be NULL)
* int pthread_mutex_init(
* pthread_mutex_t* mutex,
* const pthread_mutexattr_t* mutexattr);
*
* lock a mutex
* int pthread_mutex_lock(pthread_mutex_t* mutex);
*
* unlock a mutex
* int pthread_mutex_unlock(pthread_mutex_t* mutex);
*
* destroy a mutex
* int pthread_mutex_destroy(pthread_mutex_t* mutex);
*
* int pthread_mutexattr_setpshared(
* pthread_mutexattr_t* mattr,
* int pshared //PTHREAD_PROCESS_SHARE | PTHREAD_PROCESS_PRIVATE
* );
*
* int pthread_mutexattr_getshared(
* pthread_mutexattr_t* mattr,
* int* pshared);
*
* int pthread_mutexattr_settype(
* pthread_mutexattr_t* attr,
* int type //PTHREAD_MUTEX_TIMED_NP -- default value
* //PTHREAD_MUTEX_RECURISIVE_NP -- allow a thread lock multitimes
* //PTHREAD_MUTEX_ERRORCHECK_NO -- check error lock, return EDEADLK if the same thread want to LOCK
* //PTHREAD_MUTEX_ADAPTIVE_NO -- adaptive lock, the simplest lock
* )
*
*
* int pthread_mutexattr_gettype(
* pthread_mutexattr_t* attr,
* int* type
* )
* *********************************************/
void* work_thread(void* p)
{
if (NULL == p)
return const_cast<char*>("invalid thread argument");
pthread_mutex_t* pMutex = (pthread_mutex_t*)(p);
//current thread ID
pthread_t nThreadID = pthread_self();
int i = 0;
while(++ i <= 3)
{
//lock multi times
pthread_mutex_lock(pMutex);
pthread_mutex_lock(pMutex);
cout << "Thread " << nThreadID << " is Running! " << endl;
//and so unlock multi times
pthread_mutex_unlock(pMutex);
pthread_mutex_unlock(pMutex);
usleep(1000 * 1); //1 miliseconds
}
return const_cast<char*>("------ finish -----------");
}
void* work_thread2(void* p)
{
if (NULL == p)
return const_cast<char*>("invalid thread argument");
pthread_mutex_t* pMutex = (pthread_mutex_t*)(p);
//current thread ID
pthread_t nThreadID = pthread_self();
int i = 0;
while(++ i <= 3)
{
//if current thread can not enter mutex,
//and the function pthread_mutex_trylock will RETURN Immediatly
if ( EBUSY == pthread_mutex_trylock(pMutex))
cout << "Other thread is lock the resouce, i am waiting.." << endl;
else
{
cout << "Thread " << nThreadID << " is Running! " << endl;
pthread_mutex_unlock(pMutex);
usleep(1000 * 1); //1 miliseconds
}
}
return const_cast<char*>("------ finish -----------");
}
int main()
{
const size_t nThreadCount = 3;
pthread_t threadIDs[nThreadCount];
int nRet = -1;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
void* pRet = NULL; //thread return value
//allow a thread lock multi times
nRet = pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE_NP);
nRet = pthread_mutex_init(&mutex, &mutexattr);
if (0 != nRet)
return -1;
for (size_t i = 0; i < nThreadCount - 1; ++ i)
{
nRet = pthread_create(&threadIDs[i], NULL, work_thread, (void*)(&mutex));
if (0 != nRet)
continue;
}
nRet = pthread_create(&threadIDs[nThreadCount - 1], NULL, work_thread2, (void*)(&mutex));
if (0 != nRet)
cerr << endl << "work_thread2 created falied! " << endl;
for (size_t i = 0; i < nThreadCount; ++ i)
{
nRet = pthread_join(threadIDs[i], &pRet);
if (0 == nRet)
{
cout << " Thread " << threadIDs[i] << " Finished ! "
" It's return value is " << (char*)pRet << endl;
}
}
pthread_mutex_destroy(&mutex);
return 0;
}
3、执行结果
