Fonction pthread_cond_wait en C
Il existe un type de synchronisation qui existe entre les fils appelés serrures. Dans ce cas, le thread a besoin d'exclusion mutuelle. Il nécessite un thread pour s'exécuter à la fois. Ensuite, aussi un autre modèle commun requis lorsque plusieurs threads sont interagis. Ils sont - attendant et signalisation. Un fil attendra jusqu'à ce qu'un autre fil termine son travail. Après avoir terminé l'exécution de ce thread, le thread d'attente peut s'exécuter dans le processeur. Pour un tel type de synchronisation des threads, nous avons besoin d'une autre technique, appelée Busy Waiting On certaines variables. Pour cela, nous avons besoin d'une nouvelle primitive de synchronisation appelée variables de condition.
Ce concept de fil est disponible dans différents systèmes d'exploitation. Mais nous irons au nom, variables de condition qui est appliquée comme bibliothèque Pthread dans le système d'exploitation Linux
La fonction pthread_cond_wait () est un composant d'attente. Cette fonction par défaut effectue l'action de déverrouillage.
Exemple de programmation 1:
Dans cet exemple de programmation, nous verrons comment cette fonction s'exécute:
#inclure#inclure
#inclure
#inclure
#inclure
pthread_mutex_t m = pthread_mutex_initializer; // déclarant la variable de condition.
pthread_cond_t c = pthread_cond_initializer;
int fait = 0;
void thr_exit ()
pthread_mutex_lock (& m);
fait = 1;
pthread_cond_signal (& c);
pthread_mutex_unlock (& m);
void * enfant (void * arg) // le processus d'enfant s'exécute.
printf ("enfant \ n");
thr_exit ();
retourner null;
void thr_join ()
pthread_mutex_lock (& m);
tandis que (fait == 0)
pthread_cond_wait (& c, & m); // appelle la fonction à l'intérieur de la fonction thr_join ().
pthread_mutex_unlock (& m);
int main (int argc, char * argv [])
printf ("parent: begin \ n");
pthread_tp;
pthread_create (& p, null, enfant, null); // initialisation du fil.
thr_join ();
printf ("parent: end \ n");
retour 0;
Sortir:
Explication
Dans cet exemple de programmation, il existe deux processus appelés un thread parent et un fil d'enfant. Ici, le parent veut attendre l'enfant. Après avoir terminé l'exécution du processus enfant, le parent commence son exécution.
Pour l'intérieur du main (), nous créons le fil Parent et l'enfant. Child Thread exécute la fonction nommée enfant (). Puis le thread parent appelle la fonction jointure. Ce join () vérifie essentiellement que l'enfant a terminé. Sinon, il attendra en utilisant la fonction PTHREAD_COND_WAIT (). Lorsque l'enfant fonctionne, il appelle la sortie (). Lorsque l'exécution de l'enfant est terminée, la valeur de la variable effectuée sera 1. Ensuite, il appelle la variable du signal sur la condition. Après cela, l'exécution du thread parent commencera.
Syntaxe d'attente et de signalisation:
void thr_exit ()fait = 1;
pthread_cond_signal (& c);
void thr_join ()
si (fait == 0)
pthread_cond_wait (& c);
Que se passe-t-il si nous n'obtenons pas de verrouillage? Cela se produira une condition de course - le réveil manqué.
- Le processus parent n'a rien pour l'exécution et le fait d'aller au ralenti, car cette interruption de cas peut se produire.
- Lorsque l'enfant exécute son code et a accompli son exécution, alors il signale mais personne ne dort encore.
- Le parent a maintenant redémarré son exécution d'où il s'est terminé et doit être attendu pendant une période spécifique.
- Pour cette fonction d'attente, doit garder dans son esprit que le fil n'est pas suspendu pendant une plus longue période. Il doit être ouvert son serrure.
Exemple de programmation-2:
Dans cet exemple de programmation, nous verrons une autre utilisation de Pthread_Cond_wait Fuction.
#inclure#inclure
#inclure
#inclure
#inclure
pthread_mutex_tmutexfuel;
pthread_cond_tcondfuel; // Création de la variable de condition.
int carburant = 0;
vide * alimentation (void * arg)
pour (int i = 0; i < 5; i++)
pthread_mutex_lock (& mutexfuel);
carburant + = 15;
printf ("Got Fuel…% d \ n", carburant);
pthread_mutex_unlock (& mutexfuel);
pthread_cond_signal (& condfuel);
sommeil (1);
VOID * Véhicule (vide * arg)
pthread_mutex_lock (& mutexfuel);
Pendant (carburant < 40)
printf ("zéro carburant. En attente… \ n ");
pthread_cond_wait (& condfuel, & mutexfuel);
// Équivalent à:
// pthread_mutex_unlock (& mutexfuel);
// attendez le signal sur les condfuel
// pthread_mutex_lock (& mutexfuel);
carburant - = 40;
printf ("carburant collecté maintenant à gauche:% d \ n", carburant);
pthread_mutex_unlock (& mutexfuel);
int main (int argc, char * argv [])
pthread_ta [2];
pthread_mutex_init (& mutexfuel, null);
pthread_cond_init (& condfuel, null);
pour (int i = 0; i < 2 ; i++ )
if (i == 1)
if (pthread_create (& a [i], null, & funling, null) != 0)
perror ("Échec de la création de thread");
autre
if (pthread_create (& a [i], null, & véhicule, null) != 0)
perror ("Échec de la création de thread");
pour (int i = 0; i < 2 ; i++ )
if (pthread_join (a [i], null) != 0)
perror ("n'a pas réussi à rejoindre le thread");
pthread_mutex_destroy (& mutexfuel);
pthread_cond_destroy (& condfuel); // détruire les fils.
retour 0;
Sortir:
Explication
Ici, nous verrons l'application de la fonction pthread_cond_wait (). C'est comme quand quelqu'un veut remplir le carburant sa voiture. Il doit attendre que sa voiture soit remplie de carburant. Pour cela, nous créons deux fils. Un pour remplir le carburant dans la voiture et pour la voiture. Nous définirons deux fonctions. L'un est la fonction alimentaire () qui détermine quand remplir la voiture avec du carburant et une autre fonction est véhicule pour obtenir du carburant. Le gars qui veut remplir le carburant dans sa voiture doit attendre que le carburant soit rempli.
À l'intérieur de la fonction principale (), nous créerons deux threads pour alimenter () et pour la fonction véhicule (). Maintenant, nous allons créer une variable de condition pour attendre l'état. Pour cela, nous verrons la sortie. Lorsque les fonctions terminent leur exécution, nous détruirons ces fils.
Conclusion
La fonction pthread_cond_wait () informe lorsque nous avons fait un programme à l'aide de plusieurs threads. Cette fonction fera quelques variables de condition pour gérer ces threads. En fait, les caractéristiques de cette fonction dépend totalement du principe de attendre et signaler théorie.