A propos pthread_cond_signal et pthread_cond_wait

Question

mes questions sur pthread_cond_signal et pthread_cond_wait. Par exemple, dans le code ci-dessous, selon ma compréhension, lorsque inc_count appelle pthread_cond_signal, nombre + = 125 dans WATCH_COUNT peut être exécutée qu'après count_mutex est déverrouillé dans inc_count.

Le count_mutex a été débloquée dans WATCH_COUNT lorsque pthread_cond_wait exécuté et seulement après se verrouille pthread_mutex_unlock dans inc_count est exécuté. Ai-je raison?

void *inc_count(void *t) 
{ 
    int i; 
    long my_id = (long)t; 

    for (i = 0; i < TCOUNT; i++) 
    { 
     pthread_mutex_lock(&count_mutex); 
     count++; 

     if (count == COUNT_LIMIT) 
     { 
      pthread_cond_signal(&count_threshold_cv); 
     } 

     pthread_mutex_unlock(&count_mutex); 
    } 

    pthread_exit(NULL); 
} 

void *watch_count(void *t) 
{ 
    long my_id = (long)t; 

    pthread_mutex_lock(&count_mutex); 
    while (count < COUNT_LIMIT) 
    { 
     pthread_cond_wait(&count_threshold_cv, &count_mutex); 
     count += 125; 
    } 

    pthread_mutex_unlock(&count_mutex); 
    pthread_exit(NULL); 
} 

Answer 1

pthread_cond_wait() déverrouille le mutex à l'entrée et le verrouille à la sortie. Si un autre thread acquiert le verrou pendant ce temps, pthread_cond_wait() ne peut pas retourner jusqu'à ce que l'autre thread ait libéré le verrou.

Donc, si watch_count() est bloqué dans pthread_cond_wait() et inc_count() pistes et demande pthread_cond_signal(), alors watch_count() ne reviendra pas de pthread_cond_wait() jusqu'à ce que inc_count() a appelé pthread_mutex_unlock(). Toutefois, pthread_cond_wait() peut se réveiller même s'il n'est pas signalé. C'est ce qu'on appelle un réveil parasite. watch_count() peut donc exécuter count+=125 plusieurs fois, même si inc_count() ne s'exécute jamais ou n'appelle jamais pthread_cond_signal().

Answer 2

nombre + = 125 WATCH_COUNT peut être exécutée qu'après count_mutex est déverrouillé dans inc_count

Oui.

Le count_mutex a été débloquée dans WATCH_COUNT lorsque pthread_cond_wait exécuté et ne se bloque après pthread_mutex_unlock dans inc_count est exécuté.

Oui, en ce sens que lorsque pthread_cond_wait retours watch_count détient le mutex, et donc il ne retournera après inc_count a débloqué le mutex. (À condition que COUNT commence au-dessous COUNT_LIMIT lorsque le while est atteint pour la première fois ..)

BTW: Ce code me fait mal un peu la tête. Je ne recommanderais vraiment pas de modifier count dans watch_count car le flux de contrôle pourrait être difficile à comprendre si vous avez déjà plus d'un thread exécutant cette fonction et que vous commencez à utiliser pthread_cond_broadcast.