pthread_mutex_lock provoca un interbloqueo

Question

Estoy usando el código anterior para incrementar un contador usando 2 hilos, que toman independientemente el bloqueo mut e incrementan el contador. Estoy frente a un punto muerto después de que los hilos ingresen a esta función.

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; 
} 

¿Alguien podría decirme exactamente dónde me estoy equivocando?

Answer 1

Está intentando bloquear el mutex max veces, luego incremente counter y suéltelo una vez.

Probar:

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

Answer 2

Eso es quizá lo que ha intentado hacer:

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 o más hilos comparten datos de alcance únicamente globales o datos ubicados en la montón (malloc) .
• 2 o más subprocesos no comparten variables definidas en la pila. Estos datos son exclusivos de cada subproceso y no es necesario bloquearlos.

Te dan la bienvenida a leer in the answers lo que se comparte y lo que no es compartida etc.

Answer 3

Como principio, el mismo hilo no debe bloquear un mutex más de una vez y eso es lo que pasó aquí.

Answer 4

la inicialización del bloqueo es muy importante. Si no inicializa sus bloqueos al valor correcto, su código se rompe. Un método para inicializar el bloqueo es el siguiente:

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; 

También se puede realizar esta tarea de forma dinámica utilizando el siguiente código:

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

Al lado de inicialización de bloqueo, se debe comprobar si el código de retorno de pthread_mutex_lock para ver si falla o no, si falla, múltiples hilos pueden ingresar a la sección crítica. Para este propósito, se puede utilizar un código similar a este que comprueba el código de retorno de pthread_mutex_lock:

// 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); 
}