example - c++ 11 interproceso atómica y mutex

how to use mutex c++

Question

Tengo un programa Linux que genera varios procesos (fork) y se comunica a través de la memoria compartida POSIX. Me gustaría que cada proceso asigne un ID (0-255). Mi intención es colocar un bitvector en la región de memoria compartida (inicializada a cero) y comparar atómicamente e intercambiar un bit para asignar un ID.

¿Hay una forma amigable para c ++ 11 de hacer esto? ¿Puedo crear un conjunto de bits atómico? ¿Puedo usar un mutex a través de procesos? ¿Cómo puedo asegurar que se llame a los constructores una sola vez en todos los procesos?

Answer 1

Las primitivas de enhebrado de C ++ 11 (mutexes, atómicas, etc.) son primitivas de enhebrado . No saben nada sobre los procesos, y no son un medio para lograr la comunicación entre procesos.

Como el estándar C ++ 11 no hace mención de procesos o comunicación entre procesos, el comportamiento de tales primitivas cuando se colocan en la memoria compartida del proceso (un archivo asignado en la memoria, algún tipo de memoria asignada globalmente fuera de proceso, etc.) ) es indefinido.

Answer 2

Puede usar mutex dentro del bloque de memoria compartida, pero el mutex debe declararse como COMPARTIDO, por lo tanto no es inusual usar mutex dentro de la memoria compartida, puede crear su propia clase, es muy simple:

class Mutex {
private:
void *_handle;
public:
Mutex(void *shmMemMutex, bool recursive =false, );
virtual ~Mutex();
void lock();
void unlock();
bool tryLock();
};
Mutex::Mutex(void *shmMemMutex, bool recursive)
{
_handle = shmMemMutex;
pthread_mutexattr_t attr;
::pthread_mutexattr_init(&attr);
::pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
::pthread_mutexattr_settype(&attr, recursive ? PTHREAD_MUTEX_RECURSIVE_NP : PTHREAD_MUTEX_FAST_NP);
if (::pthread_mutex_init((pthread_mutex_t*)_handle, &attr) == -1) {
::free(_handle);
throw ThreadException("Unable to create mutex");
}
}
Mutex::~Mutex()
{
::pthread_mutex_destroy((pthread_mutex_t*)_handle);
}
void Mutex::lock()
{
if (::pthread_mutex_lock((pthread_mutex_t*)_handle) != 0) {
throw ThreadException("Unable to lock mutex");
}
}
void Mutex::unlock()
{
if (::pthread_mutex_unlock((pthread_mutex_t*)_handle) != 0) {
throw ThreadException("Unable to unlock mutex");
}
}
bool Mutex::tryLock()
{
int tryResult = ::pthread_mutex_trylock((pthread_mutex_t*)_handle);
if (tryResult != 0) {
if (EBUSY == tryResult) return false;
throw ThreadException("Unable to lock mutex");
}
return true;
}