C pthread_mutex_lock Utilisation de la fonction

Comme son nom l'indique, la fonction «pthread_mutex_lock» doit être utilisée pour verrouiller quelque chose. La bibliothèque POSIX de C a créé cette fonction pour verrouiller un thread spécifique qui peut être utilisé comme ressource partagée pour une autre fonction dans un programme. Il est nécessaire d'éviter l'impasse lors de l'exécution lorsque deux fonctions ou plus utilisent le même thread que leur ressource pour l'achèvement de l'exécution. Par conséquent, nous discuterons de l'utilisation de la fonction «pthread_mutex_lock» de la bibliothèque C POSIX dans l'Ubuntu 20.04 Système.

Exemple 01:

Commençons par le premier exemple pour voir la fonction mutex_lock () de POSIX dans le code C. Nous avons commencé avec la création de fichiers avec l'instruction «Touch» d'Ubuntu dans son shell. Ce fichier nouvellement généré peut être trouvé dans votre dossier à domicile Linux. Pour ajouter le code dans ce fichier, vous devez l'ouvrir dans un éditeur d'Ubuntu I.e., texte, nano ou vim. Nous utilisons ici l'éditeur Nano pour notre création de code. Les deux commandes sont répertoriées dans l'image.

Nous commençons notre code C avec certains en-têtes C. Ces packages d'en-tête incluent l'utilisation de la sortie d'entrée standard pour le code, les bibliothèques standard, les en-têtes de chaîne et la bibliothèque de threads POSIX. Nous avons initialisé un objet de thread POSIX «Th» de taille 3 I.e. il ne créera que 3 threads à l'aide d'ID.

Après cela, les variables de type entier sont déclarées i.e., «Je» et compte ». La variable «i» est initialisée à 0. Voici la variable pthread_mutex_t pour déclarer le «verrouillage» pour un thread. Bien que l'exécution commence à partir de la méthode principale (), nous devons d'abord examiner la fonction de thread. Cette fonction est appelée la section critique de notre code en raison de la fonction «mutex_lock». Au début de la fonction de thread, la fonction PTHREAD_MUTEX_LOCK utilise la variable de verrouillage pour verrouiller le thread particulier en utilisant son «ID» passé par la fonction Main () pthread_create ().

Maintenant, aucun autre thread ne peut utiliser ce thread tant que ce thread est déverrouillé. Donc, il continuera de traiter. La variable longue «i» est initialisée à 0 pour une utilisation dans la boucle «pour». La variable «Count» a été incrémentée de 1. La variable de comptage est utilisée dans l'instruction IMPREST pour nous faire savoir que le «Thread1» est démarré maintenant. Car «Loop» sera initialisé ici pour donner un moment de pause à l'exécution du fil. Après cela, la déclaration d'impression nous fera savoir que le fil 1 va être terminé.

La fonction pthread_mutex_unlock () est utilisée par opposition à la fonction pthread_mutex_lock () pour déverrouiller le numéro de thread 1. Le contrôle va à la méthode principale (). La fonction Main () continue de créer la fonction de thread jusqu'à ce que le nombre atteigne 3. Voici le tour de la méthode principale () après 3 threads Création, verrouillage, déverrouiller et sortir.

La fonction Main () est initialisée avec une variable entière «ERR». L'instruction «IF» est utilisée ici pour vérifier si l'initialisation du thread Mutex «L» est échoué en utilisant la fonction «pthread_mutex_init ()» de la fonction de POSIX. Si l'initialisation échoue, elle imprimera le message particulier de la déclaration d'impression. La boucle «while» est là pour voir la condition I.e. «Je» moins de 3. Il confirmera que la valeur de «i» est inférieure à 3 et, par conséquent, continuez à créer un fil. Chaque fil sera verrouillé lorsqu'il est appelé et aucun autre thread ne peut être créé jusqu'à présent.

Si nous avons obtenu une erreur dans le thread, nous afficherons cette erreur dans le shell en la convertissant en chaîne à l'aide de la méthode "Strerror". La fonction pthread_join () est utilisée pour reprendre toutes les ressources données aux threads. Enfin, la fonction "pthread_mutex_destroy ()" est utilisée pour détruire l'objet de verrouillage. Notre programme se termine ici.

Le fichier a été compilé et nous n'avons aucune erreur. En exécution, la fonction principale () a commencé et a créé un thread 1.

Après un certain temps, en raison du verrouillage, le fil 1 a terminé son exécution et terminé. Après cela, la fonction principale () a créé le thread 2 et il a été démarré.

Une fois le thread 2 entièrement exécuté, le verrou a été terminé et la fonction Main () a créé un dernier thread I.e., 3^rd fil.

Une fois le troisième thread exécuté complètement, le verrou est libéré et le contrôle est rendu à la méthode principale.

Exemple 02:

Ayons un autre exemple pour voir le fonctionnement de la fonction "pthread_mutex_lock ()". Le code a été démarré avec les mêmes fichiers d'en-tête.

Après les fichiers d'en-tête, nous avons créé une fonction de verrouillage mutex. Il y a trois fonctions. Deux fonctions de thread et 1 est la fonction liée. Thread1 et thread2 prennent l'entrée de la fonction principale () i.e. Objets threads th1 et th2. Les deux fonctions de thread appellent la méthode Show () et passent deux chaînes dans son paramètre. Lorsque la fonction «Show» démarre, elle s'enferme avec l'utilisation de la fonction «pthread_mutex_lock ()» en utilisant l'objet Mutex Lock. La première déclaration d'impression consiste à prendre le premier argument et l'affiche. Ensuite, il dort pendant 1 seconde, et la deuxième valeur d'argument sera affichée via la clause imprimée. Dans la dernière ligne, le verrou a été libéré à l'aide de la fonction "pthread_mutex_unlock ()" en utilisant l'objet de verrouillage.

La fonction Main () est démarrée avec la création de deux objets pour les threads I.e. Th1 et Th2. Deux threads ont été créés par la fonction «pthread_create» en passant Th1 et Th2 dans les paramètres. La boucle «while» est utilisée pour courir et ne pas finir pendant même une seconde. Ainsi, le programme continue de se traiter.

Le code a été compilé en premier à l'aide du compilateur «GCC» dans Ubuntu 20.04.

Lorsque le code a été exécuté, affichez la méthode appelée à l'aide de la fonction Thread1 et Thread2 les unes après l'autre. Le programme ne s'est pas arrêté après l'exécution des fils. Nous devons donc arrêter l'exécution avec force en utilisant le raccourci «Ctrl + Z».

Pour empêcher votre système de faire un traitement sans escale, nous devons supprimer la boucle «while» du code dans la méthode principale (). La phrase de retour 0 a été remplacée par la boucle «while».

Maintenant, ce programme est prêt à être compilé et exécuté. Nous avons donc compilé ce programme avec un compilateur «GCC». Après cela, l'exécution a eu lieu. Vous pouvez voir que le programme est terminé lui-même après l'exécution de deux threads. Le thread1 a fonctionné et la fonction show () s'est verrouillée lors de l'exécution. Après l'exécution, il s'est libéré et Thread2 a été exécuté. La fonction «Show» est appelée à l'intérieur et a passé certains paramètres. La fonction «show ()» s'est verrouillée elle-même et ne se rejette pas tant que l'exécution n'a pas été effectuée et la fonction Mutex_lock ne s'appelle pas. Après cela, le contrôle est rendu à la méthode principale () et le programme se termine.

Conclusion

Il s'agissait de ce que nous pouvons faire pour vous faire comprendre l'utilisation de la fonction pthread_mutex_lock dans le code C. Nous avions essayé deux programmes extrêmement différents pour la rendre compréhensible pour vous et expliqué les deux exemples assez brièvement et simplement. Nous sommes tout à fait optimistes que cet article sera idéal pour chaque utilisateur C.