如果持有互斥锁的线程没有解锁退出了，该如何处理？

问题引入

看下面一段代码，两个线程将竞争互斥锁mutex而进入临界区， 线程2在竞争互斥锁之前会sleep 2秒， 因此大概率线程1将获得互斥锁。 然而线程1执行完临界区的代码之后， 没有执行解锁操作，就退出了。

这样会导致线程2将死锁，因为该锁的状态将永远是锁定状态， 它将永远都不能获得锁。

#include<unistd.h>
#include<sys/mman.h>
#include<pthread.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<fcntl.h>
#include<string.h>
#include<stdlib.h>
#include<stdio.h>
#include <string>
#include <iostream>
using namespace std;
pthread_mutex_t mutex;void* func1(void* param)
{pthread_mutex_lock(&mutex);cout << "func1 get lock" << endl;pthread_exit(NULL);
}void* func2(void* param)
{sleep(2);pthread_mutex_lock(&mutex);cout << "func2 get lock" << endl;pthread_mutex_unlock(&mutex);return NULL;
}int main(void)
{int i;pthread_mutex_init(&mutex, NULL);pthread_t tid1, tid2;pthread_create(&tid1, NULL, func1, NULL);pthread_create(&tid2, NULL, func2, NULL);pthread_join(tid1,NULL);pthread_join(tid2,NULL);pthread_mutex_destroy(&mutex);return 0;
}

那么遇到这种情况该如何处理呢?

PTHREAD_MUTEX_ROBUST 和 pthread_mutex_consistent登场了

首先给出解决方案，如果出现了上述的场景，就需要使用互斥锁的PTHREAD_MUTEX_ROBUST属性和pthread_mutex_consistent函数。

设置PTHREAD_MUTEX_ROBUST属性需要使用pthread_mutexattr_setrobust函数, 其原型如下:

int pthread_mutexattr_setrobust(pthread_mutexattr_t *attr,int robust);

使用了该属性之后，如果某个持有互斥锁的线程还没有释放互斥锁就退出的话， 那么其他线程在进行加锁时将会收到一个EOWNERDEAD的错误，这就提示加锁线程， 目前持有锁的线程已经死亡， 可以对互斥锁的状态进行重置。

而重置的过程就需要使用到pthread_mutex_consistent方法。

#include <pthread.h>int pthread_mutex_consistent(pthread_mutex_t *mutex);

#include<unistd.h>
#include<sys/mman.h>
#include<pthread.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<fcntl.h>
#include<string.h>
#include<stdlib.h>
#include<stdio.h>
#include <string> 
#include <iostream>
using namespace std;
pthread_mutex_t mutex;void* func1(void* param)
{pthread_mutex_lock(&mutex);cout << "func1 get lock" << endl;pthread_exit(NULL);
}void* func2(void* param)
{sleep(2);int r = pthread_mutex_lock(&mutex);if (r == EOWNERDEAD){cout << "thread2 will unlock the lock" << endl;pthread_mutex_consistent(&mutex);}  cout << "func2 get lock" << endl;pthread_mutex_unlock(&mutex);return NULL;
}int main(void)
{int i;pthread_mutexattr_t attr;int err = pthread_mutexattr_init(&attr);if (err != 0)return err;pthread_mutexattr_setrobust(&attr,PTHREAD_MUTEX_ROBUST);  pthread_mutex_init(&mutex, &attr);pthread_t tid1, tid2;pthread_create(&tid1, NULL, func1, NULL);pthread_create(&tid2, NULL, func2, NULL);pthread_join(tid1,NULL);pthread_join(tid2,NULL);pthread_mutex_destroy(&mutex);return 0;
}

需要特别注意的是，如果owner死亡后，这个锁的继任者，没有调用pthread_mutex_consistent恢复锁的一致性的话，那么后续对该锁的操作除了pthread_mutex_destroy以外， 其他的操作都将失败， 并且返回ENOTRECOVERABLE错误，意味着该锁彻底可再用了， 只有将其销毁。

#include<unistd.h>
#include<sys/mman.h>
#include<pthread.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<fcntl.h>
#include<string.h>
#include<stdlib.h>
#include<stdio.h>
#include <string>
#include <iostream>
using namespace std;
pthread_mutex_t mutex;void* func1(void* param)
{pthread_mutex_lock(&mutex);cout << "func1 get lock" << endl;pthread_exit(NULL);
}void* func2(void* param)
{sleep(2);int r = pthread_mutex_lock(&mutex);
/*    if (r == EOWNERDEAD){cout << "thread2 will unlock the lock" << endl;pthread_mutex_consistent(&mutex);}
*/cout << "func2 get lock" << endl;pthread_mutex_unlock(&mutex);return NULL;
}void* func3(void* param)
{sleep(10);int r = pthread_mutex_lock(&mutex);cout << "err = " << r << endl;
/*    if (r == EOWNERDEAD){cout << "thread2 will unlock the lock" << endl;pthread_mutex_consistent(&mutex);}
*/cout << "func3 get lock" << endl;pthread_mutex_unlock(&mutex);return NULL;
}int main(void)
{int i;pthread_mutexattr_t attr;int err = pthread_mutexattr_init(&attr);if (err != 0)return err;pthread_mutexattr_setrobust(&attr,PTHREAD_MUTEX_ROBUST);pthread_mutex_init(&mutex, &attr);pthread_t tid1, tid2, tid3;pthread_create(&tid1, NULL, func1, NULL);pthread_create(&tid2, NULL, func2, NULL);pthread_create(&tid3, NULL, func3, NULL);pthread_join(tid1,NULL);pthread_join(tid2,NULL);pthread_join(tid3,NULL);pthread_mutex_destroy(&mutex);return 0;
}

结论：

• 在多线程/多进程程序中，离开临界区时候一定需要释放互斥锁。 可以使用RAII的设计方法， 离开作用域的时候栈对象析构， 从而释放锁。
• 在多线程/多进程程序中,如果持有锁的owner意外退出，如果还想继续使用该锁, 那么该锁的后续的owner需要使用PTHREAD_MUTEX_ROBUST和pthread_mutex_consistent对互斥锁的状态进行恢复。