Question

If I understand correctly, then foo1() fails to unlock &private_value_. As a result, foo2()’s thread_mutex_lock does not work since foo1() never released it.

What are the other consequences?

int main ( ... )

foo1();
foo2();

return 0;
}

foo1()
{
 pthread_mutex_lock(&private_value_);
 do something 
 // no unlock!
}

foo2()
{
 pthread_mutex_lock(&private_value_)
 do something
 pthread_mutex_unlock(&private_value_);
}

Answer 1

There seems to be some confusion here between how the program should have been written and how the program, as currently written, will behave.

This code will cause deadlock, and this does not indicate that there is something wrong with how the mutexes are working. They’re working exactly how they are supposed to: If you try to re-acquire a non-recursive mutex that is already locked, your code will block until the mutex is unlocked. That’s how it’s supposed to work.

Since this code is single-threaded, the blocking in foo2 will never end, and so your program will deadlock and not progress. That is most likely not how the program should work (because it’s not a very useful program that way). The error is not in how the mutexes are functioning, but in how the programmer chose to employ them. The programmer should have put an unlock call at the end of foo1.