C Utilisation de la fonction SEM_INIT

La fonction SEM_INIT () fonctionne pour initialiser un sémaphore sans nom. Maintenant, la question se pose: qu'est-ce qu'un sémaphore? Le sémaphore est un concept qui traite d'un processus ou d'une synchronisation de threads. Un sémaphore est une structure de données utilisée pour synchroniser le processus et aider les threads sans interagir avec les autres threads pour continuer leur opération ensemble. Le type de sémaphore que Linux prend en charge est le sémaphore POSIX. POSIX est utilisé comme interface portable du système d'exploitation. C POSIX dispose d'une bibliothèque de packages construite avec standard C. POSIX ajoute quelques fonctionnalités supplémentaires aux programmes utilisés dans les normes C.

Pourquoi les sémaphores sont-ils utilisés?

En utilisant des threads, nous rencontrons plusieurs problèmes conditionnels impliquant des conditions de course. Cela se produit lorsque deux threads ou plus ont besoin des mêmes données ou informations en même temps que provoquant un conflit. Donc, pour éviter ce type de situation contradictoire, nous utilisons des sémaphores. Il existe trois principaux types de sémaphores. L'un est un sémaphore binaire, et un autre est un sémaphore de comptage.

Nous utilisons différentes fonctions dans la gamme de sémaphore comme SEM_WAIT, SEM_POST et SEM_INIT. SEM_INIT est le sujet à l'étude dans cet article.

SEM_INIT

Comme nous l'avons discuté ci-dessus, pour initialiser le sémaphore dans les threads, nous utilisons la fonction SEM_INIT. Ici, nous utilisons un drapeau ou une bannière qui identifie le partage du sémaphore avec la procédure Fork ().

Syntaxe

# SEM_INIT (SEM * SEM, int Pshared, int Value (Unsigned));

SEM: Cette fonctionnalité aide le sémaphore à être dans un état prêt.

Pshared: Cet argument de paramètre est fondamental dans la déclaration de sémaphore. Comme il détermine l'état du sémaphore nouvellement initialisé. Qu'il soit partagé ou non entre les processus ou les threads. Si la valeur est non nul, cela signifie que le sémaphore est partagé entre deux processus ou plus, et si la valeur est nulle, cela signifie que le sémaphore est partagé entre les threads.

Valeur: Il spécifie la valeur qui doit être attribuée au sémaphore nouvellement créé qui est attribué initialement.

Implémentation de SEM_INIT

Pour exécuter des sémaphores dans le programme C, nous avons besoin d'un compilateur GCC. Mais ce n'est pas suffisant. «-Lpthread» est utilisé pour exécuter le code. 'un.c 'est le nom du fichier. Une autre chose est que ici nous utilisons '.Out 'avec le nom de fichier au lieu d'utiliser le fichier indépendamment.

Exemple 1

Tout d'abord, nous ajoutons deux bibliothèques ayant des sémaphores et du pthread pour se livrer à l'utilisation des packages C. Comme SEM_INIT, d'autres sémaphores sont utilisés dans ce programme; Ici, nous en discuterons.

SEM_WAIT ()

Cette fonction est utilisée pour tenir un sémaphore ou pour continuer à attendre. Si la valeur fournie au sémaphore est négative, l'appel est bloqué et le cycle est fermé. Alors que tout autre fil, lorsqu'il est appelé, les sémaphores bloqués sont éveillés.

SEM_POST ()

La méthode SEM_POST est utilisée pour augmenter la valeur du sémaphore. La valeur est incrémentée par SEM_POST lorsqu'elle est appelée.

SEM_DESTROY ()

Si nous voulons détruire le sémaphore, nous utilisons la méthode SEM_DESTROY. Maintenant encore, concentrez-vous sur le code source fourni ici. Tout d'abord, la fonction «Await» est utilisée ici. Cela fera d'abord attendre le fil pour que les autres puissent effectuer une tâche. Un message s'affiche que le thread est entré en appelant la fonction. Après cela, une fonction «sommeil» est appelée 5 secondes.

Deux threads sont créés en fonction des fonctions principales, 2 threads sont créés, mais le premier dort 5 secondes après l'acquisition de la serrure. Donc le deuxième thread n'est pas entré lorsqu'il est appelé. Il entrera après 5-2 secondes lorsqu'il sera appelé.

SEM_POST fonctionnera après la fonction de sommeil; SEM_POST fonctionnera et affichera un message d'état complet. Dans le programme principal, le sémaphore est initialisé d'abord, puis les deux threads sont créés à l'aide de Pthread. Nous utilisons la fonction pthread_join pour rejoindre les threads. Et à la fin, les sémaphores sont détruits.

Enregistrer le fichier avec l'extension de .C; Le code sera compilé et l'exécution sera effectuée. En exécution, vous verrez que le premier message s'affiche, puis il faut quelques secondes pour terminer, car nous avons fourni la fonction de sommeil avec 5 secondes, donc après ce temps, le deuxième message pour le premier thread s'affiche.

Fréquemment le premier message pour le deuxième thread s'affiche.

Le deuxième message prendra à nouveau le temps de continuer.

Exemple 2

Avant de passer vers le deuxième exemple, nous devons d'abord comprendre le concept du problème de l'écrivain du lecteur. Supposons qu'une base de données que vous souhaitez partager entre les processus fonctionne simultanément. Certains de ces processus ou threads peuvent lire la base de données uniquement. Dans le même temps, d'autres peuvent aimer modifier la base de données. Nous discriminons entre ces deux-là en déclarant le premier en tant que lecteur et le second en tant qu'écrivain. Si deux lecteurs accèdent aux données partagées, cela ne provoquera aucun effet.

Pour minimiser l'occurrence de ces types de difficultés, nous devons aider les écrivains à accéder à la base de données partagée pour y écrire. Ce problème est synchronisé et connu sous le nom de problème des lecteurs-rédacteurs.

Il existe de nombreuses variations dans ce problème. Le premier traite du problème qu'aucun lecteur n'attendra à moins qu'un écrivain utilise des objets partagés.

Ce programme fournit la solution pour le premier problème de lecteur-rédacteur. Dans ce code source C, nous avons utilisé 10 lecteurs et 5 procédures pour démontrer la solution. Les deux premiers compteurs sont pris qui sont appelés zéro. Le non-lecture identifie le nombre de lecteur. En évoluant vers la fonction de l'écrivain, deux fonctions de sémaphore sont utilisées ici, la première est l'attente, et ce dernier est le post. Cela affichera le numéro de l'écrivain.

Après la fonction de l'écrivain, la fonction du lecteur est déclarée ici. L'écrivain modifiera la base de données afin que le lecteur ne puisse pas entrer ou modifier tout ce qui est acquis par un verrouillage.

# Pthread_mutex_lock (& ​​mutex);

Le nombre de non-lecteurs est ensuite incrémenté. Ici, un chèque est appliqué de la mise en place if. Si la valeur est 1, cela signifie que c'est le premier lecteur pour que l'écrivain soit bloqué. Si le non-lecture est 0, après avoir vérifié, cela signifie que c'est le dernier lecteur, nous allons donc désormais permettre l'écrivain pour la modification.

# Pthread_mutex_unlock (& ​​mutex);

Nous nous dirigerons vers le programme principal après la fonction du lecteur et de l'écrivain. Ici, nous avons initialisé 10 lecteurs et 5 écrivains. La fonction SEM_INIT sera initialisé le sémaphore. Car les boucles sont utilisées ici séparément pour les lecteurs et les écrivains. Pthread_create créera les fonctions de lecture et d'écriture. De plus, pthread_join rejoindra les threads. Chacun pour Loop utilisera cette articulation 5 fois à des fins de rédacteur, puis 10 fois à des fins de lecteur.

Et à la fin, le sémaphore est détruit respectivement après utilisation. Compiler le code puis l'exécuter. Vous verrez que des nombres aléatoires pour le lecteur sont générés dans les 10 tailles de tableau avec le compte 1. Et pour l'écrivain, 5 nombres sont modifiés.

Conclusion

L'article 'SEM_INIT' est une fonction utilisée par les sémaphores du processus de lecture multithaux pour hiérarchiser les tâches qui se produisent simultanément. Il existe de nombreuses autres fonctions liées aux sémaphores, également discutées ici. Nous avons expliqué deux exemples élémentaires pour développer l'utilisation de SEM_INIT dans les fonctions et autres fonctionnalités.