Rendimento garantito con pthread_cond_wait e pthread_cond_signal

Question

Supponendo che ho un programma C con 3 thread POSIX, che condividono una variabile globale, mutex e variabile di condizione, due dei quali eseguono il seguente psuedocode:

...process data...
pthread_mutex_lock( &mutex );
variable = data_ptr;
pthread_cond_signal( &cond );
pthread_mutex_unlock( &mutex );

E la terza in esecuzione:

while(1) {
    while( variable == NULL ) {
        pthread_mutex_wait( &cond, &mutex );
    }
    printf( "Data is %d", *variable );
}

È sicuro supporre che il terzo thread vedrà i dati di ciascuno dei primi due?

In altri termini, se un thread si accoppia su un mutex e una variabile di condizione, è sicuro supporre che sarà il prossimo ad ottenere il blocco se viene segnalato, piuttosto che qualche altro thread che potrebbe essere aspettando sulla serratura?

Answer 1

Non esiste pthread_mutex_wait. Suppongo che intendi:

pthread_mutex_lock(&mutex);
/* ... */
while (1) {
  while (variable == NULL)
    pthread_cond_wait(&cond, &mutex);
  printf("Data is %d", *variable);
}
/* ... */
pthread_mutex_unlock(&mutex);

Non è garantito che il terzo thread vedrà i dati da entrambi. pthread_cond_signal risveglierà il terzo thread, ma potrebbe non prendere immediatamente il mutex. Uno degli altri scrittori potrebbe prendere prima il mutex. Tuttavia puoi ottenere ciò che vuoi con un po 'più di lavoro:

void put(int *p) {
  pthread_mutex_lock(&mutex);
  while (variable)
    pthread_cond_wait(&cond_empty, &mutex);
  variable = p;
  pthread_cond_signal(&cond_full);
  pthread_mutex_unlock(&mutex);
}

int *get() {
  int *ret;

  pthread_mutex_lock(&mutex);
  while (!variable)
    pthread_cond_wait(&cond_full, &mutex);
  ret = variable;
  variable = NULL;
  pthread_cond_signal(&cond_empty);
  pthread_mutex_unlock(&mutex);

  return ret;
}

Aspettando esplicitamente la lettura della variabile, evitiamo la potenziale condizione di razza.

Answer 2

Ecco cosa ho trovato nello standard :

  

4.13 Politica di pianificazione

     

Una politica di pianificazione influisce sull'ordinamento di processi o thread:

     

[...]

     

  
• Quando un processo o un thread è un thread bloccato e diventa un thread eseguibile
  

     

Le implementazioni conformi definiscono il modo in cui ciascuna delle politiche di programmazione può modificare le priorità o influenzare in altro modo l'ordinamento di processi o thread in ciascuna delle occorrenze sopra elencate. Inoltre, le implementazioni conformi definiranno in quali altre circostanze e in che modo ciascuna politica di pianificazione può modificare le priorità o influire sull'ordinamento di processi o thread.

Quindi apparentemente non definito. Non è sorprendente: in generale, non puoi assumere nulla su quale thread eseguibile verrà pianificato per l'esecuzione.

Answer 3

Secondo la manpage pthread_cond_wait

  

Le discussioni che sono sbloccate devono contendere il mutex in base alla politica di pianificazione (se applicabile) e come se ognuna avesse chiamato pthread_mutex_lock ().

Sfortunatamente, per quanto ne so, non esiste una politica di pianificazione che ti dia il comportamento che desideri.