C 错误检查互斥与递归互斥

我想知道是否可以使用

PTHREAD\u mutex\u ERRORCHECK

mutex自己创建一个递归互斥类型，结果如下：

typedef结构{
pthread_mutex_t mutex；
uint32_t死锁；
pthread_t所有者；
布尔被锁定；
}pthread_recursivemutex_t；
int pthread_recursivemutex_init（pthread_recursivemutex_t*mutex）
{
int ret；
pthread_mutextatr_t attr；
互斥->死锁=0；
ret=pthread\u mutexattr\u init（&attr）；
如果（ret！=0）{
返回ret；
}
（void）pthread_mutextatr_settype（&attr，pthread_MUTEX_ERRORCHECK）；
ret=pthread\u mutex\u init（&mutex->mutex，&attr）；
（void）pthread_mutexattr_destroy（&attr）；
互斥->isLocked=FALSE；
返回ret；
}
void pthread_recursivemutex_lock（pthread_recursivemutex_t*mutex）
{
int ret；
布尔锁定；
锁定=互斥->已锁定；
__sync_synchronize（）；
如果（锁定==TRUE）{
if（pthread_equal（pthread_self（），mutex->owner）==0）{
返回；
}
}       
ret=pthread\u mutex\u lock（&mutex->mutex）；
如果（ret==0）{
互斥->死锁=0；
__sync_synchronize（）；
互斥->isLocked=TRUE；
}else if（ret==EDEADLK）{
互斥->死锁+=1；
}
}
void pthread_recursivemutex_unlock（pthread_recursivemutex_t*mutex）
{
如果（互斥->死锁==0）{
（void）pthread_mutex_unlock（&mutex->mutex）；
__sync_synchronize（）；
互斥->isLocked=FALSE；
}否则{
互斥->死锁-=1；
}
}
void pthread\u recursivemutex\u destroy（pthread\u recursivemutex\u t*mutex）
{
（void）pthread\u mutex\u destroy（&mutex->mutex）；
}

我发现这种类型的递归互斥比具有

PTHREAD\u mutex\u recursive

属性的互斥要快得多：

迭代次数：1000000
pthread_mutex_t:71757微秒
pthread_recursivemutex_t:48583微秒

测试代码（每个调用1000000次）：

void mutex_test（）
{
pthread_mutex_lock（&recursiveMutex）；
pthread_mutex_lock（&recursiveMutex）；
pthread_mutex_unlock（&recursiveMutex）；
pthread_mutex_unlock（&recursiveMutex）；
}
void recursivemutex_test（）
{
pthread_recursivemutex_lock（&myMutex）；
pthread_recursivemutex_lock（&myMutex）；
pthread_recursivemutex_unlock（&myMutex）；
pthread_recursivemutex_unlock（&myMutex）；
}

pthread\u recursivemutex\u t

的速度几乎是

pthread\u mutex\u t

的两倍？！但两者的行为方式都一样

---

这个解决方案安全吗？

您的互斥锁无法工作：您不检查哪个线程正在获取锁

---

您允许多个线程锁定同一个互斥锁。

它们的行为方式不同-其中一个称为递归。我指的是pthread\u mutex\t（带递归）和pthread\u recursivemutex\t。如果锁定两次，两者都不会使调用线程死锁。即使检查所有者线程，recursivemutex也会更快。为什么？现在慢了。。。我想换个说法：目前是什么阻止了他们这么做？而且。。。你试过了吗？因为只有一个线程可以获得互斥锁，所以所有其他线程都会被阻塞。