Posix mutex en c

«L'utilisation de mutex est la méthode pour prévenir les situations de course qui sont les plus fréquemment utilisées. Mutex, qui fait référence à l'exclusion mutuelle, nous donne essentiellement un verrou de pêne dormant qui empêche plusieurs utilisateurs d'accéder et de modifier simultanément les données cruciales. Chaque fois que plusieurs processus ou plus utilisent le même processus que leur support pour terminer leur traitement, l'impasse doit être évitée. Le sujet principal de la discussion d'aujourd'hui sera d'utiliser la fonction POSIX MUTEX pour éviter l'impasse avec différentes méthodes avec le langage C dans Ubuntu 20.04 Système. Avant de faire quoi que ce soit avec vos extraits de code, nous devons installer le compilateur «GCC»."

Exemple 01

Nous allons commencer notre première illustration des fonctions POSIX Mutex avec les en-têtes nécessaires. Sans ces en-têtes, notre script de C ne sera pas opérationnel comme nous le voulons. Le premier stdio.L'en-tête H est responsable de l'utilisation des entrées et sorties régulières dans le code. L'en-tête «STDLIB» standard est responsable de l'utilisation en douceur des fonctions de bibliothèque standard dans l'extrait de code. L'Unistd.L'en-tête H est un incontournable pour rencontrer des problèmes liés à Unicodes. Voici la bibliothèque pour utiliser des variables de chaîne et des fonctions liées à la chaîne dans le langage C, i.e., chaîne.H.

Enfin, la bibliothèque est le «pthread.En-tête h ”qui est indispensable lorsque vous souhaitez utiliser le multithreading dans vos extraits. Cette bibliothèque comprend la création de threads, la jonction de thread, le verrouillage du fil, le déverrouillage du fil et de nombreuses autres fonctions liées au multithreading.

#inclure
#inclure
#inclure
#inclure
#inclure

Après avoir lancé les en-têtes nécessaires, nous allons initialiser 2 threads à l'aide de l'objet "Pthread_t" de la bibliothèque du thread. La valeur «t» sera utilisée comme identifiant de thread dans un avenir proche. Ensuite, une variable entière «i» est initialisée à 0, et la variable «C» a été déclarée pour compter les threads. L'objet Mutex Lock «ML» a été généré à l'aide de l'objet PTHEAD_MUTEX_T. Voici la fonction de thread «t», qui va verrouiller et déverrouiller le fil. Pour verrouiller le thread d'appel, nous utilisons la fonction pthread_mutex_lock () à l'aide du verrouillage «ML» tout en comptant le numéro de thread.

Les instructions printf () sont là pour nous parler de l'initialisation et de la fin d'un fil spécifique. Dans l'initialisation et la fin, la fonction de thread «t» est verrouillée et ne peut pas être accessible par d'autres threads. En fin de compte, la fonction pthread_mutex_unlock () est utilisée pour déverrouiller le thread spécifique et donner accès à d'autres threads.

pthread_t t [2];
int i = 0;
INT C;
pthread_mutex_lock (& ​​ml);
non signé long i = 0;
C + = 1;
printf ("initié% d thread… \ n", c);
pour (i = 0; i<(0xFFFFFFFF); i++)
;
sommeil (5);
printf ("terminé% D thread… \ n", c);
sommeil (5);
pthread_mutex_unlock (& ​​ml);
retourner null;

La fonction principale () commence à partir de l'instruction «if» qui a vérifié une condition. Il utilise la fonction pthread_mutex_init () en le faisant passer l'objet de verrouillage «ml» et la valeur nul pour initialiser le verrou de mutex. Si la valeur renvoyée de la fonction init () n'est pas égale à 0, l'instruction printf () affichera que le verrouillage mutex n'a pas été initialisé en raison d'un problème. Pendant ce temps, la boucle while () utilise la condition pour la variable «i», qui devrait être inférieure à 2. S'il est inférieur à 2, alors la fonction thread_create () sera appelée en passant l'ID de thread «T» comme pointeur et pointeur vers la fonction de thread «t». Si le fil était créé avec succès, il renverrait «0» à la variable «E».

Dans le cas où il revient autre que 0, il imprimera un, je.e., en utilisant la fonction Strinror et incrément la valeur d'une variable «i». Cette fonction est responsable de l'appel de la fonction de thread T pour deux threads différents. La fonction pthread_join () utilise l'ID de thread pour les rejoindre avec la fonction principale (), et la fonction PTHREAD_MUTEX_DESTROY () est là pour détruire le verrouillage après que toutes les fonctions ont été exécutées. Le retour à un message Main () sera affiché à la fin de ce programme après les exécutions de threads.

int main()
if (pthread_mutex_init (& ml, null) != 0)
printf ("Impossible d'initialiser le verrouillage de mutex… \ n");
retour 1;

alors que je<2)
int e = pthread_create (& t [i], null, & t, null);
si (e != 0)
printf ("Échec de la création de thread: [% s]", Stronterror (e));
i ++;

pthread_join (t [0], null);
pthread_join (t [1], null);
pthread_mutex_destroy (& ml);
printf ("Bonjour! Nous sommes de retour dans la méthode principale… \ n ");
retour 0;

Nous compilons le test.Fichier C avec le compilateur «GCC» et l'option -lpthread pour l'exécution des threads. L'exécution montre que le premier thread a eu accès à la fonction «T» et verrouillé.

Une fois le verrouillage libéré du premier thread, puis l'accès à la fonction T a été donné au deuxième fil, et il a été verrouillé et déverrouillé également.

En fin de compte, les deux threads ont été exécutés et la fonction principale () a obtenu le contrôle.

Exemple 02

Voici une autre façon de démontrer l'utilisation de Posix Mutex pour verrouiller et déverrouiller les fils. Dans cet exemple, nous n'avons pas besoin de l'Unistd.HI-IN-HEUR, donc nous n'allons pas l'utiliser. Sinon, tous les en-têtes sont ici, que nous avons utilisés dans l'exemple ci-dessus. L'objet Pthread_Mutex_T est utilisé pour créer une serrure mutex «ML». La méthode Main () commence par initialiser deux threads, T1 et T2, en utilisant l'objet PTHEAD_T. Il utilise deux fois la fonction pthread_create () pour créer des threads en appelant les fonctions t1 et t2 en les passant les ID d'initialisation de threads comme pointeurs, i.e., T1 et T2. Sur la création de thread, la fonction T1 et T2 a été exécutée une après l'autre. Chacune de ces fonctions est appelée fonction Test () en passant 2 valeurs de chaîne comme paramètres.

La fonction de test est utilisée ici pour verrouiller et déverrouiller des threads spécifiques qui l'appellent, je.e., T1 et T2. Pour le verrouillage des threads, la fonction PTHREAD_MUTEX_LOCK () est utilisée, et pour le déverrouillage, la fonction PTHREAD_MUTEX_UNLOCK () est utilisée, I.e., Les deux utilisent le verrou de mutex «ML». Dans le processus de verrouillage et de déverrouillage, les instructions printf sont utilisées avec un sommeil de 5 secondes après chaque. La première méthode printf () affichera le premier argument transmis à la fonction de test, et la deuxième méthode printf () affichera le deuxième argument de chaîne transmis à la fonction de test.

#inclure
#inclure
#inclure
#inclure
pthread_mutex_t ml;
vide * test (char * p, char * q)
pthread_mutex_lock (& ​​ml);
printf ("% s… \ n", p);
sommeil (5);
printf ("% s… \ n", q);
sommeil (5);
pthread_mutex_unlock (& ​​ml);

void * t1 (void * z)
Test ("initié", "1er thread");
void * t2 (void * z)
Test ("initié", "2e thread");
int main()
pthread_t t1, t2;
pthread_create (& t1, null, & t1, null);
pthread_create (& t2, null, & t2, null);
tandis que (1)
sortie (0);

En compilant, cela vous montrera un avertissement, mais vous pouvez l'ignorer un instant.

L'exécution du code compilé montre que le premier thread a été initié et a obtenu toutes les ressources de la fonction de test.

Après cela, le verrou est sorti, et le 2ème thread a obtenu les ressources. Après le deuxième thread, nous devons quitter l'exécution avec force.

Conclusion

Le concept POSIX MUTEX est brièvement expliqué pour éviter l'impasse dans la programmation C. Par conséquent, nous avons utilisé les fonctions pthread_mutex_lock et pthread_mutex_unlock pour effectuer cela. En utilisant ces fonctions dans nos extraits de code, nous avons assuré l'utilisation des ressources d'un thread à la fois.