« Bien que chaque langage de programmation possède de nombreuses bibliothèques à des fins spécifiques, la bibliothèque POSIX de C a sa place. Il a été conçu pour créer une grande harmonisation entre les processus et aide beaucoup à utiliser le multithreading dans les programmes, c'est-à-dire à créer plusieurs threads et à synchroniser leur exécution. Dans ce guide d'aujourd'hui, vous verrez une illustration simple de l'utilisation des sémaphores POSIX en C. Pour les exemples de code C de base, nous devons configurer son compilateur dans le système. Mais, avant cela, nous devons mettre à jour le système car c'est une étape indispensable pour la bonne exécution du code. Ainsi, la requête affichée dans le composant logiciel enfichable ci-joint est indispensable pour mettre à jour et mettre à niveau votre système d'exploitation Linux avec l'utilitaire 'apt'.
Ce processus a nécessité environ 55 Ko d'espace sur votre plate-forme Linux pour effectuer les mises à jour en douceur. Si vous êtes prêt à donner autant d'espace, appuyez sur 'y' pour continuer. Le traitement sera terminé dans quelques minutes.
Une fois le système entièrement mis à niveau, nous allons configurer le compilateur du langage C dans notre système avec l'utilitaire apt-get dans la commande 'install'. Utilisez 'gcc' comme mot-clé, et c'est tout.
sem_init()
Un nouveau sémaphore serait créé lorsqu'il existe déjà un sémaphore non identifié en 's' ; sinon, ce sémaphore déjà existant sera supprimé. Tout au long de cette méthode, 's' représente une instance de Semaphore qui a été construite, et partagé est un signal ou un fanion qui indique si le sémaphore peut être distribué avec une méthode forkée() ou autrement. La valeur d'entrée sert de point de départ défini pour le sémaphore.
Int sem_init ( ni_t * s, entier partagé, valeur entière non signée ) ;
Sem_wait()
En exécutant une action de verrouillage de sémaphore sur le sémaphore spécifié par « s », la méthode sem_wait() maintient ce sémaphore. La procédure sem-wait sera utilisée pour retenir un sémaphore ou le laisser en ligne. Certains des processus précédemment surchargés se réveillent lorsqu'un autre processus invoque sem_post().
entier sem_wait ( ni_t * s ) ;
pas d'article()
Lorsque sem post est appelé, la valeur est augmentée, puis l'une des opérations précédemment sauvegardées ou en attente commence à s'exécuter, c'est-à-dire déverrouille le sémaphore déjà verrouillé.
entier sem_post ( ni_t * s ) ;
no_destroy()
Un sémaphore sans nom initialisé 's' est détruit en utilisant la fonction sem destroy().
entier sem_destroy ( ni_t * s ) ;
Exemple
Pour comprendre les sémaphores, nous allons d'abord créer un fichier C puis y ajouter un code. Pour en créer un, utilisez la requête 'toucher', et vous trouverez le nouveau fichier dans le dossier de départ de votre système.
Maintenant, vous devez ouvrir votre fichier C vide avec un éditeur simple pour y générer un bon code. Nous avons essayé l'éditeur 'nano' jusqu'à présent, comme le montre le cliché ci-dessous.
Comme nous le savons tous, tous les langages de programmation ne peuvent pas fonctionner sans bibliothèques car ces bibliothèques contiennent un grand nombre de classes, de structures, de fonctions et d'objets à utiliser pour le fonctionnement global du système. Nous commençons donc ce programme C avec l'utilisation de certaines bibliothèques de base et indispensables pour les sémaphores POSIX.
Pour utiliser ces bibliothèques dans le code, nous devons utiliser le caractère '#' avec le mot-clé 'include' pour chaque bibliothèque. À l'heure actuelle, nous avons ajouté un total de 4 bibliothèques indispensables à ce programme. Sinon, notre programme ne fonctionnera pas correctement. La première bibliothèque d'en-tête 'stdio.h' est généralement indispensable dans chaque programme C car elle nous permet d'avoir des opérations d'entrée et de sortie dans le code. Par conséquent, nous l'utilisons pour ajouter en douceur des entrées et obtenir des sorties du code. La deuxième bibliothèque que nous utilisons ici est le 'pthread.h' qui est un must pour l'utilisation de la programmation de threads, c'est-à-dire le multithreading.
Nous utiliserons cette bibliothèque pour créer des threads dans un programme. La bibliothèque suivante et la plus importante dans ce code est le 'semaphore.h'. Il a été utilisé pour synchroniser en douceur les fils. Enfin, la bibliothèque est 'unistd.h', qui nous permet d'utiliser diverses fonctions et constantes définies par l'utilisateur. Maintenant, nous avons déclaré le sémaphore 's' en utilisant l'objet intégré 'sem_t' de la bibliothèque de sémaphores. Voici la fonction de thread définie par l'utilisateur 'T' sans type de retour. Il utilise certaines fonctions de sémaphore intégrées pour effectuer la synchronisation. La fonction sem_wait() est là pour contenir le sémaphore « s » en utilisant le caractère « & ».
Dans le maintien, l'instruction printf() a été exécutée avec la fonction 'sleep' pour mettre ce programme en veille pendant 4 secondes. Une autre instruction printf() affiche un nouveau message et la fonction sem_post() est exécutée pour libérer le verrou sur le sémaphore 's'.
#include#include
#include
#include
ni_t s;
annuler * J ( annuler * argument ) {
sem_wait ( & s ) ;
printf ( 'Accueillir! \n ' ) ;
dormir ( 4 ) ;
printf ( 'Au revoir! \n ' ) ;
sem_post ( & s ) ;
}
Examinons attentivement la méthode main() de ce programme C pour les sémaphores. La fonction sem_init() a été utilisée ici pour créer un nouveau sémaphore 's' qui n'a pas été distribué avec une méthode forkée(), c'est-à-dire '0', et son point de départ est défini sur 1. L'objet pthread_t du pthread La bibliothèque de C a été utilisée pour créer deux threads à l'aide de deux objets thread, o1 et o2. L'instruction printf() est là pour montrer que nous allons créer le premier thread en utilisant la fonction pthread_create() à la ligne suivante.
Nous avons passé l'objet thread o1 à cette fonction avec des restrictions NULL et appelé la fonction 'T' en le passant dans les paramètres. Après un sommeil de 4 secondes, un autre thread a été créé avec l'objet o2, et la fonction pthread_join() est utilisée ici pour joindre les threads avec une fonction main(). La fonction sem_destroy() est là pour détruire le sémaphore 's', et tous les threads bloqués seront également libérés.
int main ( ) {sem_init ( & s, 0 , 1 ) ;
pthread_t o1, o2 ;
printf ( 'Dans un 1er Thread maintenant... \n ' ) ;
pthread_create ( & o1,NULL,T,NULL ) ;
dormir ( 4 ) ;
printf ( 'Dans un 2ème fil maintenant... \n ' ) ;
pthread_create ( & o2,NULL,T,NULL ) ;
pthread_join ( o1,NULL ) ;
pthread_join ( o2,NUL ) ;
no_destroy ( & s ) ;
revenir 0 ;
}
Nous compilons le programme C avec le compilateur « Gcc » ; les options '-lrt' et '-lpthread' sont utilisées pour exécuter les fonctions de thread POSIX. Lors de l'exécution de la requête '.a/.out', le premier thread a été créé. Il se met en veille après l'impression du premier message.
Le deuxième thread a été synchronisé, et après 4 secondes, le premier thread a été libéré et le deuxième thread s'est verrouillé pendant 4 secondes.
En fin de compte, le deuxième fil a également été publié.
Conclusion
C'est tout sur les sémaphores POSIX en C tout en utilisant certaines de ses fonctions principales pour synchroniser différents threads. Après avoir parcouru cet article, vous comprendrez de mieux en mieux POSIX.