Verrouiller un mutex plusieurs fois dans le même thread

Il sonne comme le pthread mutex n'est pas réentrant. Vous pouvez travailler autour de ce avec un drapeau indiquant si votre fils a déjà verrouillé le mutex:

bool haveLock = false;//thread variable 
pthread_mutex_t waiting_barcode_mutex; //également thread var 

mylock() 
{ 
si( haveLock ) return; //pas besoin de verrouiller deux fois 
pthread_mutex_lock(&waiting_barcode_mutex); 
haveLock = true; 
} 

myunlock() 
{ 
haveLock = false; 
pthread_mutex_unlock(&waiting_barcode_mutex); //ou quel que soit l'appel de déverrouillage est 
} 

OriginalL'auteur atk

Le code ci-dessous montre qu'il n'y a pas de problème de verrouillage d'une section critique deux fois ou trois fois ou N fois avant d'appeler le code de déverrouillage sur pthread. Vous pouvez le faire de multiples verrous sur le même thread, successivement, avant de déverrouiller sans se soucier mais vous l'esprit, CE n'EST PAS un bon programmeur. La bonne façon est d'appeler lock(), laisser le thread d'exécution de la section critique et appel de déverrouillage(), de sorte que les autres threads peuvent exécuter le même morceau de code de verrouillage et de déverrouillage (appelé, en section critique). Le code ci-dessous empêche n'importe quel programmeur de mésaventures à l'aide d'ATTRIBUTS sur pthread).

À lire!

//Example program using a thread locking multiple times sequentially before unlocking
#include <iostream>
using namespace std;
pthread_mutexattr_t     _attr;
pthread_mutex_t         _mutex;
///
///Initialize mutex with error return locking mechanism (does not block
///its own thread if multiple locks occurs.
///
void InitMutex()
{
//Initialize mutex
int ret=0;
ret = pthread_mutexattr_settype(&_attr, PTHREAD_MUTEX_ERRORCHECK_NP);   //PTHREAD_MUTEX_ERRORCHECK_NP avoids double locking on same thread.
if(ret != 0)
{
printf("Mutex attribute not initialized!!\n");
}
ret = pthread_mutex_init(&_mutex, &_attr);
if(ret != 0)
{
printf("Mutex not initialized!!\n");
}
}
///
///Locks the critical section
///
int lock_me()
{
return pthread_mutex_lock(&_mutex);
}
///
///Unlocks the critical section
///
int unlock_me()
{
return pthread_mutex_unlock(&_mutex);
}
int main()
{
InitMutex(); //Very important
int ret = 0;
ret = lock_me();    //return value of 0 - OK
cout << "First lock returns: "<< ret<< endl;
ret = lock_me();    //returns a value like 35 - ERROR, but ignores locking again
cout << "Second lock returns: "<< ret<< endl;
//Do something in this critical section. No other thread can execute this at this time before unlock. Other threads (if any) wait at lock() waiting for main function to unlock() first.
ret = unlock_me();  //unlocks the critical section. All is OK
cout << "First unlock returns: "<< ret<< endl;
ret = unlock_me();  //returns error value of 1, nothing to lock
cout << "Second unlock returns: "<< ret<< endl;
ret = unlock_me();  //same as above, nothing to do. Ignore and move on!
cout << "Third unlock returns: "<< ret << endl;
//The main() thread will never have a race condition ;) All iz well!!
pthread_mutexattr_destroy(&_attr);    //clean up the mutex attribute
pthread_mutex_destroy(&_mutex);       //clean up the mutex itself
}

De SORTIE:

Première écluse retourne: 0

Deuxième verrou retourne: 35

D'abord déverrouiller retourne: 0

Deuxième déverrouiller retourne: 1

Troisième déverrouiller retourne: 1

OriginalL'auteur Sammy