Phenquestions
Fil POSIX :
Sur les plates-formes Linux, l'API standard pthread des langages C et C++ pour toutes sortes de fonctions liées aux threads. Il est également connu sous le nom de thread POSIX qui permet aux utilisateurs de créer de nombreux threads pour que les processus simultanés se déroulent. Il est mieux utilisé dans les systèmes ou processeurs multicœurs pour implémenter des threads sur le noyau pour réaliser le système.
Mise en œuvre:
Il est nécessaire d'inclure ce pthread.h fichier d'en-tête dans le script initialement. Cela aidera à utiliser les fonctions de la bibliothèque pthreads. Pour exécuter le fichier c, les commandes suivantes
$ cc -pthread fichier.c
OU ALORS
$ cc -lpthread fichier.c
Les fonctions définies dans la bibliothèque pthreads peuvent inclure :
pthread_create :
Il est utilisé pour créer un nouveau fil
Paramètres de pthread_create :
Il a les paramètres suivants :
fil: Cela agit comme un pointeur vers une valeur entière non signée. Il renvoie l'identifiant du thread formé.
les attributs: Ce paramètre agit comme un pointeur vers une structure. Il est utilisé pour définir les attributs d'un thread qui peuvent être la politique de planification, l'adresse de la pile, etc.
start_routine : Ce paramètre est un pointeur vers un sous-programme implémenté par le thread.
argument: Ce paramètre est un pointeur vers void avec différents arguments à la fonction prédéfinie au début de l'argument
Syntaxe:
>> int pthread_create(pthread_t * thread, const pthread_attributes_t * attr, void * (*start_routine)(void *), void *argument);
pthread_exit :
Il est utilisé pour terminer ou terminer un thread
Paramètres de pthread_exit :
La méthode utilisée à la fin de la méthode/processus accepte un paramètre retval qui est un indicateur obligatoire à un entier. Il stocke l'état du thread de telle sorte que le thread se termine. Ce doit être une variable globale. Cela permettra au prochain thread en ligne de rejoindre le thread s'il est disponible.
Syntaxe:
>> void pthread_exit(void *retval);pthread_join :
C'est une fonction utilisée au moment d'attendre la fin du thread.
Paramètres pour pthread_join :
Les paramètres utilisés ici sont :
thread_id : C'est l'ID du thread que le thread en ligne attend.
thread_return : C'est le paramètre qui agit comme un pointeur vers l'emplacement particulier où nous avons défini l'état de sortie.
Syntaxe:
>> int pthread_join(pthread_t thread_identification, void **thread_return);pthread_self :
Il s'agit d'une méthode utilisée pour obtenir l'identifiant du thread actuellement en ligne.
Syntaxe:
>> pthread_t pthread_self(void);pthread_equal :
Cette méthode est utilisée pour comparer dans le cas où deux threads sont équivalents ou non. Si deux threads se ressemblent, la fonction renverra une valeur autre que zéro en réponse.
Syntaxe:
>> int pthread_equal(pthread_t thread1, pthread_t thread2) ;pthread_cancel :
Cette méthode est utilisée pour envoyer une demande d'annulation
Paramètre pour pthread_cancel :
Le paramètre utilisé est à renseigner obligatoirement pour annuler la demande.
Syntaxe:
>> int pthread_cancel(pthread_t nom_fil);pthread_detach :
C'est la méthode qui est utilisée pour séparer un fil. Il n'a besoin d'aucun thread pour se joindre à la terminaison. Toutes les ressources s'exécutant dans le thread sont libérées dès que le thread est détaché.
Paramètre de pthread_detachr :
C'est le paramètre qui accepte le paramètre obligatoire thread id. C'est un must pour être détaché.
Syntaxe:
>> int pthread_detach(pthread_t thread);Exemple de code :
Voici un exemple de code pour montrer l'implémentation de la fonction décrite ci-dessus. Nous avons utilisé un compilateur gcc pour compiler ces fonctions.
// Programme pour afficher les fonctions du thread#inclure
#inclure
#inclure
// Appel du thread POSIX, indispensable dans les systèmes UNIX/LINUX
pthread_t tid[2];
void*Fonction(void *arg)
long non signé i = 0 ;
pthread_t id = pthread_self();
if(pthread_equal(id,tid[0]))
// Condition pour que les threads soient égaux
printf("\n Le premier thread est en cours de traitement\n");
autre
printf("\n Le deuxième thread est en cours de traitement \n");
// Threads en cours de traitement.
pour(i=0; je<(0x255);i++);
renvoie NULL ;
int main(void)
entier je = 0;
Dans la terreur;
// Création d'un nouveau fil
alors que je < 2)
erreur = pthread_create(&(tid[i]), NULL, &Function, NULL);
si (erreur != 0)
printf("\n Impossible de créer le thread :[%s]", strerror(error));
autre
printf("\n Le fil a été créé avec succès\n");
// Thread créé avec succès
je++ ;
dormir(5) ;
renvoie 0 ;
Le code est écrit dans un éditeur de texte ; vous pouvez utiliser n'importe quel éditeur en fonction de votre choix. Ensuite, enregistrez-le dans votre emplacement préféré.
Le fichier est enregistré dans le système informatique puis est accessible. Le fichier que nous avons enregistré s'appelait test.c. Pour y accéder, tapez la commande suivante dans la fenêtre du terminal :
$ sudo test gcc.c -lpthread
Ensuite, pour exécuter la sortie, saisissez la commande suivante :
$ ./une.en dehors
Production attendue:
La sortie que nous avons obtenue en réponse au code précédent est indiquée ci-dessous :
Conclusion:
Le didacticiel couvrait le processus de base de la création de threads et discutait de toutes les méthodes couramment utilisées dans sa création. Thread est une instance d'un processus. Nous avons ensuite guidé les utilisateurs à travers les fameux paramètres utilisés par chaque processus ainsi que les syntaxes afin qu'ils puissent les utiliser dans leurs programmes informatiques. Ici, nous avons également partagé un exemple de code à titre d'exemple pour mieux comprendre l'idée de créer un programme C dans POSIX. Le compilateur que nous avons utilisé était gcc dans le système Linux. Les utilisateurs peuvent également opter pour n'importe quel autre compilateur en fonction de leurs préférences.
