pthread_mutex_lock verursacht Deadlock

Question

Ich benutze den obigen Code, um einen Zähler mit 2 Threads zu erhöhen, die unabhängig voneinander den Mut Sperren und Inkrementieren Zähler. Ich bin mit einem Deadlock konfrontiert, nachdem die Threads in diese Funktion eingetreten sind.

pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER; 

void *increment_counter(void *counter_addr) 
{ 
    int max = MAX_COUNTER_VALUE; 
    int iter; 
    int counter; 

    for(iter=0;iter< max ;iter++) 
    // LOCK 
    pthread_mutex_lock(&mut); 
    counter++; 
    // UNLOCK 
    pthread_mutex_unlock(&mut); 
    return NULL; 
} 

Könnte mir bitte jemand sagen, wo genau liege ich falsch?

Answer 1

Sie versuchen, die Mutex max mal zu sperren, dann counter zu erhöhen und sie einmal freigeben.

Versuchen:

for(iter=0;iter< max ;iter++) 
{ 
    // LOCK 
    pthread_mutex_lock(&mut); 
    counter++; 
    // UNLOCK 
    pthread_mutex_unlock(&mut); 
} 
return NULL; 

Answer 2

, dass vielleicht ist das, was Sie zu tun versucht:

int max = MAX_COUNTER_VALUE; 
int iter; 
int counter; 
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER; 

void *increment_counter(void *counter_addr) 


{ 

    pthread_mutex_lock(&mut);  
    for(iter=0;iter< max ;iter++) 
     counter++; 
    pthread_mutex_unlock(&mut); 
    return NULL; 
} 

• 2 oder mehr Threads befindet Umfang Daten oder Daten nur global teilen auf dem Heap (malloc) .
• 2 oder mehr Threads teilen keine Variablen, die auf dem Stack definiert sind Daten sind für jeden Thread eindeutig und müssen nicht gesperrt werden.

Sie werden begrüßt, in the answers zu lesen, was geteilt wird und was wird nicht geteilt usw.

Answer 3

Als Prinzip ein Mutex mehr als einmal der gleiche Thread nicht sperren soll, und das ist, was hier passiert ist.

Answer 4

Sperre Initialisierung ist sehr wichtig. Wenn Sie Ihre Sperren nicht mit dem richtigen Wert initialisieren, bricht der Code ab. Eine Methode für die Sperre der Initialisierung ist die folgende:

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; 

auch Sie diese Aufgabe dynamisch, indem Sie den folgenden Code tun können:

int rc = pthread_mutex_init(&lock, NULL); 
assert(rc == 0); // always check success! 

Neben Schloss Initialisierung sollten Sie überprüfen, für den Return-Code von pthread_mutex_lock um zu sehen, ob es fehlschlägt oder nicht, als ob es fehlschlägt, kann mehrere Threads den kritischen Abschnitt eingeben. Zu diesem Zweck können Sie einen Code ähnlich wie diese verwendet werden, die für den Return-Code von pthread_mutex_lock prüft:

// Use this to keep your code clean but check for failures 
// Only use if exiting program is OK upon failure 
void Pthread_mutex_lock(pthread_mutex_t *mutex) { 
int rc = pthread_mutex_lock(mutex); 
assert(rc == 0); 
}