Funzione pthread_cond_wait in c
Esiste un tipo di sincronizzazione che esiste tra i thread chiamati blocchi. In questo caso, il thread necessita di reciproca esclusione. Richiede un thread da eseguire alla volta. Quindi, anche un altro modello comune richiesto quando vengono interagiti più thread. Stanno - aspettando e segnalando. Un thread aspetterà fino a quando l'altro thread non termina il suo lavoro. Dopo aver completato l'esecuzione di questo thread, il thread in attesa può eseguire nel processore. Per questo tipo di sincronizzazione del thread, abbiamo bisogno di un'altra tecnica, chiamata impegnata in attesa di alcune variabili. Per questo, abbiamo bisogno di una nuova primitiva di sincronizzazione chiamata variabili di condizione.
Questo concetto di thread è disponibile in diverso sistema operativo. Ma andremo al nome, variabili di condizione che viene applicata come libreria PThread nel sistema operativo Linux
La funzione pThread_cond_wait () è un componente di attesa. Questa funzione per impostazione predefinita esegue l'azione di sblocco.
Programmazione Esempio-1:
In questo esempio di programmazione vedremo come esegue questa funzione:
#includere#includere
#includere
#includere
#includere
pThread_mutex_t m = pThread_mutex_initializer; // Dichiarazione della variabile di condizione.
pThread_cond_t c = pthread_cond_initializer;
int fatto = 0;
void thr_exit ()
pThread_mutex_lock (& m);
fatto = 1;
pThread_cond_signal (& c);
pThread_mutex_unlock (& m);
void *Child (void *arg) // Processo figlio esegue.
printf ("Child \ n");
thr_exit ();
restituire null;
void thr_join ()
pThread_mutex_lock (& m);
while (fatto == 0)
pThread_cond_wait (& c, & m); // Chiama la funzione all'interno della funzione Thr_Join ().
pThread_mutex_unlock (& m);
int main (int argc, char* argv [])
printf ("genitore: inizio \ n");
pThread_tp;
pThread_create (& p, null, figlio, null); // Inizializzazione del thread.
thr_Join ();
printf ("genitore: end \ n");
restituzione 0;
Produzione:
Spiegazione
In questo esempio di programmazione esistono due processi chiamati thread genitore e un thread figlio. Qui, il genitore vuole aspettare il bambino. Dopo aver completato l'esecuzione del processo figlio, il genitore avvia la sua esecuzione.
Per l'interno principale () creiamo il thread genitore e figlio. Il thread figlio esegue la funzione denominata figlio (). Quindi il thread genitore chiama la funzione join. Questo join () fondamentalmente controlla che il bambino sia finito. Altrimenti aspetterà usando la funzione pThread_cond_wait (). Quando il bambino funziona, chiama l'uscita (). Quando l'esecuzione del bambino viene eseguita, il valore della variabile fatta sarà 1. Quindi, chiama il segnale sulla variabile della condizione. Dopodiché inizierà l'esecuzione del thread genitore.
Aspetta e sintassi del segnale:
void thr_exit ()fatto = 1;
pThread_cond_signal (& c);
void thr_join ()
if (done == 0)
pThread_cond_wait (& c);
Cosa succede se non otteniamo un blocco? Si verificherà una condizione di gara - wakeup mancato.
- Il processo genitore non ha nulla per l'esecuzione e vanno in ozioso, poiché può verificarsi interruzioni del caso.
- Quando il bambino esegue il suo codice e ha realizzato la sua esecuzione, allora non è ancora letto.
- Il genitore ora ha riavviato la sua esecuzione da dove è finita e deve essere attesa per un periodo specifico.
- Per questa funzione di attesa deve tenere nella sua mente che il thread non è sospeso per un periodo di tempo più lungo. Deve essere aperto la sua serratura.
Programmazione Esempio-2:
In questo esempio di programmazione vedremo un altro uso di pThread_cond_wait.
#includere#includere
#includere
#includere
#includere
pThread_mutex_tmutexfuel;
pthread_cond_tcondfuel; // Creazione della variabile di condizione.
int carburante = 0;
void* alimentazione (void* arg)
per (int i = 0; i < 5; i++)
pThread_mutex_lock (& mutexfuel);
carburante += 15;
printf ("Got Fuel ... %d \ n", carburante);
pThread_mutex_unlock (& mutexfuel);
pThread_cond_signal (& condfuel);
sonno (1);
void* veicolo (void* arg)
pThread_mutex_lock (& mutexfuel);
mentre (carburante < 40)
printf ("zero carburante. Aspettando ... \ n ");
pThread_cond_wait (& condfuel, & mutexfuel);
// Equivalente a:
// pThread_mutex_unlock (& mutexfuel);
// Attendi il segnale su Condiluel
// pThread_mutex_lock (& mutexfuel);
carburante -= 40;
printf ("carburante raccolto ora a sinistra: %d \ n", carburante);
pThread_mutex_unlock (& mutexfuel);
int main (int argc, char* argv [])
pThread_ta [2];
pThread_mutex_init (& mutexfuel, null);
pThread_cond_init (& condfuel, null);
per (int i = 0; i < 2 ; i++ )
if (i == 1)
if (pThread_create (& a [i], null e carburante, null) != 0)
perror ("non è riuscito a creare thread");
altro
if (pthread_create (& a [i], null e veicolo, null) != 0)
perror ("non è riuscito a creare thread");
per (int i = 0; i < 2 ; i++ )
if (pThread_join (a [i], null) != 0)
Perror ("non è riuscito a unirsi al thread");
pThread_mutex_destroy (& mutexfuel);
pThread_cond_destroy (& condfuel); // distruggendo i thread.
restituzione 0;
Produzione:
Spiegazione
Qui vedremo l'applicazione della funzione pThread_cond_wait (). È come quando qualcuno vuole riempire il carburante la sua auto. Deve aspettare fino a quando la sua auto sarà riempita di carburante. Per questo, creiamo due thread. Uno per riempire il carburante in macchina e per l'auto. Definiremo due funzioni. Uno è la funzione di rifornimento () che determina quando riempire l'auto con carburante e un'altra è la funzione veicolo () per ottenere carburante. Il ragazzo che vuole riempire il carburante nella sua auto deve aspettare fino a quando il carburante è riempito.
All'interno della funzione principale () creeremo due thread per la funzione di alimentazione () e per veicoli (). Ora creeremo una variabile di condizione per attendere la condizione. Per questo vedremo l'output. Quando le funzioni completano la loro esecuzione, distruggeremo questi thread.
Conclusione
La funzione pThread_cond_wait () avvisa quando abbiamo eseguito un programma con l'aiuto di più thread. Questa funzione farà alcune variabili di condizione per gestire questi thread. In realtà, le caratteristiche di questa funzione dipendono totalmente dal principio di Aspetta e segnala teoria.