thread exit but still hold mutex - linux

Question

A thread which hold mutex died. Another thread will deadlock when it calls "pthread_mutex_lock", although I use "PTHREAD_MUTEX_ERRORCHECK" attribute.
#include <pthread.h>
#include <iostream>
#include <unistd.h>
using namespace std;
pthread_mutex_t mutex;
void *handler(void *)
{
cout << "child thread" << endl;
int ret = pthread_mutex_lock(&mutex);
cout << "child ret: " << ret << endl;
pthread_exit(NULL);
}
int main()
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
pthread_mutex_init(&mutex, &attr);
pthread_mutexattr_destroy(&attr);
pthread_t tid;
pthread_create(&tid, NULL, handler, NULL);
sleep(2);
cout << "father awake" << endl;
int ret = pthread_mutex_lock(&mutex);
cout << "father ret: " << ret << endl;
return 0;
}
Output:
[LINUX ENVIRONMENT]: Linux ubuntu 3.19.0-25-generic #26~14.04.1-Ubuntu SMP

Answer 1

You are perhaps thinking of the robust attribute of mutexes (pthread_mutexattr_setrobust()), rather than of the errorcheck type of mutex. A robust mutex would have notified your main thread that the holder of the mutex's lock had terminated with EOWNERDEAD.
The PTHREAD_MUTEX_ERRORCHECK type, on the other hand, simply guards against three kinds of errors:
attempting to recursively lock one's own locked mutex (not applicable here)
attempting to unlock a mutex locked by another thread (not applicable here)
attempting to unlock an unlocked mutex (not applicable here)

Answer 2

This is a small example of using the pthread_mutexattr_setrobust call to allow for setting the mutex that was never unlocked back to a consistent state:
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
pthread_mutex_t lock;
void dropped_thread(void)
{
printf("Setting lock...\n");
pthread_mutex_lock(&lock);
printf("Lock set, now exiting without unlocking...\n");
pthread_exit(NULL);
}
int main(int argc, char *argv[])
{
pthread_t lock_getter;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST);
pthread_mutex_init(&lock, &attr);
pthread_mutexattr_destroy(&attr);
pthread_create(&lock_getter, NULL, (void *) dropped_thread, NULL);
sleep(2);
printf("Inside main\n");
printf("Attempting to acquire unlocked mutex?\n");
pthread_mutex_consistent(&lock);
pthread_mutex_unlock(&lock);
pthread_mutex_lock(&lock);
printf("Successfully acquired lock!\n");
pthread_mutex_destroy(&lock);
return 0;
}
As you can see by making the call to pthread_mutex_consistent after setting the mutex robustness, its state is marked as consistent again.