Fil POSIX avec programmation C
Fil POSIX:
Dans les plates-formes Linux, l'API standard C et C ++ Languages Pthread pour toutes sortes de fonctions liées au thread. Il est également connu comme un thread POSIX qui permet aux utilisateurs de créer de nombreux threads pour que les processus simultanés s'écoulent. Il est mieux utilisé dans les systèmes ou processeurs multi-fond pour implémenter des threads sur le noyau pour réaliser le système.
Mise en œuvre:
Il faut inclure ce pthread.Fichier d'en-tête H 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
$ 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 de discussion: Cela agit comme un pointeur vers une valeur entière non signée. Il renvoie l'ID de thread du thread qui est formé.
les attributs: Ce paramètre agit comme un pointeur vers une structure. Il est utilisé pour définir les attributs d'un fil qui peut être la politique de planification et d'adresse de 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 à vide 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 mettre fin à un fil
Paramètres de pthread_exit:
La méthode utilisée à la fin de la méthode / processus accepte un retour de paramètre 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 fil suivant en ligne de rejoindre le fil s'il est disponible.
Syntaxe:
>> void pthread_exit (void * retval);
pthread_join:
Ceci est une fonction utilisée au moment de l'attente de la terminaison du fil.
Paramètres pour pthread_join:
Le paramètre utilisé ici est:
thread_id: C'est l'ID du fil pour lequel le fil 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:
Ceci est une méthode utilisée pour obtenir actuellement l'ID du fil.
Syntaxe:
>> pthread_t pthread_self (void);
pthread_equal:
Cette méthode est utilisée pour comparer au cas où deux threads sont équivalents ou non. Si deux threads se ressemblent, la fonction renvoie 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 obligatoire pour être entré pour annuler la demande.
Syntaxe:
>> int pthread_cancel (pthread_t threadName);
pthread_detach:
Ceci est la méthode utilisée pour séparer un fil. Il n'a pas besoin de fil pour se joindre à la terminaison. Toutes les ressources exécutées dans le fil sont libérées dès que le fil est détaché.
Paramètre de pthread_detachr:
C'est le paramètre qui accepte l'ID de thread de paramètre obligatoire. C'est un must d'être détaché.
Syntaxe:
>> int pthread_detach (thread pthread_t);
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 de thread
#inclure
#inclure
#inclure
// Appel du thread POSIX, un incontournable dans les systèmes Unix / Linux
pthread_t tid [2];
Fonction void * (void * arg)
non signé long i = 0;
pthread_t id = pthread_self ();
if (pthread_equal (id, tid [0]))
// Condition pour les threads égaux
printf ("\ n Le premier thread est en cours de traitement \ n");
autre
printf ("\ n Second Thread est en cours de traitement \ n");
// threads en cours de traitement.
pour (i = 0; i<(0x255);i++);
retourner null;
int Main (vide)
int i = 0;
Dans la terreur;
// Création d'un nouveau fil
alors que je < 2)
error = pthread_create (& (tid [i]), null, & function, null);
if (erreur != 0)
printf ("\ n n'a pas été en mesure de créer le thread: [% s]", Strerror (erreur));
autre
printf ("\ n thread a été créé avec succès \ n");
// Thread créé avec succès
i ++;
sommeil (5);
retour 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 accessible. Le fichier enregistré par nous a été nommé test.c. Pour y accéder, saisissez la commande suivante dans la fenêtre du terminal:
$ sudo gcc test.c -lpthread
Ensuite, pour exécuter la sortie, tapez la commande suivante:
$ ./un.dehors
Production attendue:
La sortie que nous avons obtenue en réponse au code précédent est indiquée ci-dessous:
Conclusion:
Le tutoriel a couvert le processus de base de la création de thread et a discuté de toutes les méthodes couramment utilisées dans sa création. Le thread est une instance d'un processus. Nous avons ensuite parcouru les utilisateurs à travers les célèbres paramètres utilisés par chaque processus avec les syntaxes afin qu'ils puissent les utiliser dans leurs programmes informatiques. Ici, nous avons également partagé un exemple de code en tant qu'échantillon 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 tout autre compilateur en fonction de leur préférence.