recursive-mutex

Quoting [thread.mutex.recursive] : A thread that owns a recursive_mutex object may acquire additional levels of ownership by calling lock() or try_lock() on that object. It is unspecified how many levels of ownership may be acquired by a single thread. If a thread has already acquired the maximum level of ownership for a recursive_mutex object, additional calls to try_lock() shall fail, and additional calls to lock() shall throw an exception of type system_error . Is there a lower bound greater than 1 for the " maximum level of ownership "? What about recursive pthread mutexes? There is no

I have seen some people hate on recursive_mutex : http://www.zaval.org/resources/library/butenhof1.html But when thinking about how to implement a class that is thread safe (mutex protected), it seems to me excruciatingly hard to prove that every method that should be mutex protected is mutex protected and that mutex is locked at most once. So for object oriented design, should std::recursive_mutex be default and std::mutex considered as an performance optimization in general case unless it is used only in one place (to protect only one resource)? To make things clear, I'm talking about one

I am a bit confused on how to declare a recursive mutex using pthread. What I try to do is have only one thread at a time be able to run a piece of code(including functions) but after scepticism I figured out that the use of mutexes would not work and that instead I should use recursive mutexes. Here is my code: pthread_mutex_lock(&mutex); // LOCK item = queue_peek(queue); // get last item in queue item_buff=item; // save item to a buffer queue_removelast(queue); // remove last item from queue pthread_mutex_unlock(&mutex); // UNLOCK So what I try to do is just read/remove from the queue

I understand recursive mutex allows mutex to be locked more than once without getting to a deadlock and should be unlocked the same number of times. But in what specific situations do you need to use a recursive mutex? I'm looking for design/code-level situations. For example when you have function that calls it recursively, and you want to get synchronized access to it: void foo() { ... mutex_acquire(); ... foo(); ... mutex_release(); } without a recursive mutex you would have to create an "entry point" function first, and this becomes cumbersome when you have a set of functions that are