mutex

How exactly i can destroy a pthread mutex variable ? Here is what i want to do. I want to have objects (structure variables) cached , which are looked up by key. I want to have minimum granularity of locks here. So i want to have a lock for each object probably embedded in the structure so that i can have object level locking. Now the problem is how to safely destroy these objects ? Looks like first step is to remove the object from the lookup table so that the object is not accessible in future that is fine. I want to free the object from the cache. Now how to destroy/free mutex correctly ?

Mutexes are pretty common in many programming languages, like e.g. C/C++. I miss them in Java. However, there are multiple ways I could write my own class Mutex : Using a simple synchronized keyword on Mutex . Using a binary semaphore . Using atomic variables, like discussed here . ...? What is the fastest (best runtime) way? I think synchronized is most common, but what about performance? Mutexes are pretty common in many programming languages, like e.g. C/C++. I miss them in Java. Not sure I follow you (especially because you give the answer in your question). public class SomeClass {

We have an internal memory manager that we use with one of our products. The memory manager overrides the new and delete operators, and works fine in single-threaded appliations. However, I'm now tasked to make it work with multi-threaded applications too. To my understanding the following pseudo code should work, but it hangs on a spin, even with try_lock() . Any ideas? Update #1 Causes "Access Violation": #include <mutex> std::mutex g_mutex; /*! \brief Overrides the Standard C++ new operator \param size [in] Number of bytes to allocate */ void *operator new(size_t size) { g_mutex.lock(); //

i'm having some trouble using a C++11 std::mutex in my class I have a variable called semaphore of type std::mutex. So I positioned my semaphore.lock() and semaphore.unlock() before and after my critical section class Database { public: Database(string, string, string, string); virtual ~Database(); struct sMyHome getMyHome(void); struct sPhysical getPhysical(int); struct sSystemInfo getSystemInfo(void); void commitSystemInfo(struct sSystemInfo); struct sTSensors getTSensors(int); struct sWireless getWireless(int); struct sWirelessConf getWirelessConf(int); struct sWirelessStatus

Several processes access shared memory, locking it with the mutex and pthread_mutex_lock() for synchronization, and each process can be killed at any moment (in fact I described php-fpm with APC extension, but it doesn't matter). Will the mutex be unlocked automatically, if the process locked the mutex and then was killed? Or is there a way to unlock it automatically? Edit: As it turns out, dying processes and threads have similar behavior in this situation, which depends on robust attribute of mutex . Aaron Digulla That depends on the type of mutex. A "robust" mutex will survive the death of

I'm wondering if it's possible to lock multiple mutexes at the same time, like: Mutex1.Lock(); { Mutex2.Lock(); { // Code locked by mutex 1 and 2. } Mutex2.Unlock(); // Code locked by mutex 1. } Mutex1.Unlock(); It would be very useful for some situations. Thanks. It is possible but the order of locking must be consistent throughout the application otherwise deadlock is a likely result (if two threads acquire the locks in opposite order then each thread could be waiting on the other to release one of the locks). Recommend using a scoped lock and unlock facility for exception safety, to ensure