C pthread_detach Utilisation de la fonction

Comme nous le savons tous, les threads sont la partie principale de tout traitement tout en travaillant dans tout environnement multiprocesseur. Le filetage est également un concept utilisé dans la programmation. Le langage C propose une API nommée «POSIX» pour permettre à l'utilisation de threads de différentes fins utilisées dans notre morceau de code. L'un de ces threads est la fonction «pthread_detach ()» utilisée pour identifier ou spécifier un thread comme déconnecté complètement. Il s'assurera également de libérer toutes les ressources utilisées par ce fil particulier. Dans cet article, nous plaiderons l'utilisation de la fonction PTHREAD_DETACH () dans le langage C à l'aide de l'Ubuntu 20.04 Système.

Exemple 01:

Ayons le premier exemple pour voir le fonctionnement de la fonction pthread_detach. Commencez par le terminal en le lançant, je.e., Ctrl + alt + t. Nous utiliserons des commandes spécifiques pour créer un fichier C, l'ouvrir et l'exécuter. La toute première commande consiste à générer un nouveau fichier avec, je.e., touche. Ce nouveau fichier doit s'ouvrir dans un tel éditeur dans lequel nous pouvons y ajouter du code et y apporter des modifications. Nous utilisons ici l'éditeur «Nano» via sa commande.

Nous avons commencé l'implémentation du premier exemple avec certains fichiers d'en-tête qui sont nécessaires pour que ce code s'exécute. Notre code contient deux fonctions définies par l'utilisateur et 1 méthode main (). Comme l'exécution commence toujours à partir de la méthode principale (), nous commençons également l'explication à partir du principal (). La fonction principale () est appelée la méthode «Createt» dans sa première ligne. Maintenant, le contrôle est donné à la fonction «Createt». Cette fonction crée un objet «th» pour obtenir l'ID de thread à l'aide de pthread_t intégré mutable. L'instruction printf montre que nous sommes actuellement dans le thread principal ou 1^St fonction.

La fonction «pthread_create» est utilisée ici pour créer un nouveau thread dans cette fonction en utilisant le nom d'une autre fonction, i.e., Nouveau et liant la variable «th» pour référencer l'ID. L'instruction «IF» est utilisée pour vérifier si cette fonction Main () et d'autres threads nouvellement créés sont égaux ou non. Cela a été fait en assimilant les ID des deux fils. La référence mutable «th» au nouveau thread et pthread_self () renvoie l'ID de la fonction «Createt». Si les deux threads correspondent, il imprimera «les threads sont les mêmes»; Sinon, «les fils ne sont pas les mêmes."La fonction pthread_join () garantit que l'exécution du thread principal est terminée jusqu'à ce que le nouveau thread soit exécuté et non terminé. Maintenant, le contrôle est entièrement terminé vers un nouveau fil.

Dans un nouveau fil, la fonction de sommeil est utilisée. Ainsi, le système dormira pendant 10 secondes, et après cela, une nouvelle exécution aura lieu. La fonction pthread_detach () est là pour détacher complètement le nouveau thread à partir de sa fonction d'appel, i.e., «Createt."Ici, pthread_self () est utilisé pour découvrir l'ID du« nouveau fil »pour le détachement. L'instruction printf affichera que ce thread de fonction sortira maintenant. Le système dormira à nouveau pendant les 10 prochaines secondes en utilisant la même méthode «Sleep ()» de C. La fonction pthread_exit () est là pour terminer rapidement le thread actuel, qui est en ce moment «Nouveau."Maintenant, le contrôle est rendu à la fonction" Createt ". Après être revenu dans ce fil principal, nous avons rencontré une nouvelle instruction PRINTF pour afficher que nous sommes de retour dans la fonction «Createt». Maintenant, nous devons utiliser une autre fonction pthread_exit () pour fermer également le thread «Createt» et rendre le contrôle à la fonction principale (). Donc, nous l'avons fait jusqu'à présent, et le contrôle est rendu. Ici, le programme se termine. À mesure que le programme est terminé, nous devons le compiler avec le compilateur C sur Ubuntu 20.04.

Vous devez vous assurer que le compilateur C est déjà configuré dans votre machine d'extrémité. Nous utilisons le compilateur GCC dans notre coquille. Ainsi, le nom d'un fichier avec le mot clé «-lpthread» est utilisé pour compiler le code selon l'image ci-dessous.

Après avoir compilé le code, nous devons l'exécuter pour voir la sortie. La commande pour l'exécution est «./un.Out »comme ci-dessous. Lorsque nous avons exécuté le fichier de code, il a commencé la fonction principale et la fonction principale () appelée la fonction «Createt». L'énoncé printf de «Createt» affiché «Inside Main Thread» et a créé un nouveau fil nommé nouveau. Une comparaison des deux fils a été faite, et il renvoie les deux threads ne sont pas les mêmes. Ensuite, un système dort 10 secondes.

Après 10 secondes, il rejoint le fil créé nouveau. Le nouveau thread a été détaché de la fonction «Createt» et affiché que nous sommes dans la «nouvelle» fonction de thread. Le système dort à nouveau pendant les 10 prochaines secondes et sort du nouveau fil.

Maintenant, le contrôle est terminé par rapport au fil «Createt», et il a sprinté que nous sommes de retour dans le fil principal. Une fois le thread «Createt» terminé, la fonction principale () a reçu le contrôle. Par conséquent, le programme se termine ici avec succès.

Exemple 02:

Jetons un aperçu assez différent de l'exemple de fonction Pthread_Detach en C. Nous avons commencé notre code C avec les mêmes en-têtes de bibliothèque avec #include mot-clé pour rendre notre code exécutable. 1 fonction main () et 1 fonction définie par l'utilisateur nommé «Nouveau» est défini. La fonction «nouvelle» sera utilisée comme fonctions de thread. Nous commençons l'explication à partir d'une méthode principale (). Le mutable pthead_t déclare la variable «th» pour obtenir l'ID de thread d'un nouveau fil. L'instruction PRINTF montre que nous avons commencé la fonction principale et que 10 secondes de sommeil en utilisant la méthode «sommeil». Le prochain printf affiche qu'une fonction de thread sera créée et que la fonction pthread_create () de POSIX est utilisée pour cette raison jusqu'à présent.

Le «TH» est utilisé comme paramètre de la nouvelle fonction de création de thread pour obtenir l'ID d'un nouveau thread. La fonction pthread_join () est là pour suspendre complètement l'exécution d'une méthode main () jusqu'à ce que le nouveau thread, je.e., Nouveau, exécute. Maintenant, la nouvelle fonction est démarrée. La fonction pthread_detach () est là pour détacher complètement cette fonction de la fonction principale () en reprenant ses ressources. La fonction pthread_exit () garantira que le nouveau thread n'est plus exécuté. Par conséquent, sa déclaration printf ne sera pas exécutée. Le thread Main () sera terminé après avoir exécuté sa fonction PTHEAD_EXIT ().

Commençons par la compilation de code avec gcc. Heureusement! C'était un succès.

Donc, nous avons utilisé la même chose "./un.instruction out ici aussi. La fonction Main () a commencé à s'exécuter en premier à mesure que l'instruction d'impression sortira. Maintenant, le système dort 10 secondes.

Après 10 secondes, l'instruction d'impression suivante est exécutée et affichée que le nouveau thread est créé. Le contrôle est terminé vers un nouveau thread, et il est détaché de la fonction principale () sans exécuter sa déclaration printf. Par conséquent, notre sortie est quelque chose comme ci-dessous.

Conclusion:

Donc, il s'agissait d'utiliser la fonction PTHEAD_DETACH de POSIX en C pour détacher complètement un fil du fil d'appel principal. En le gardant assez simple et en expliquant brièvement les illustrations, nous avons fait de notre mieux pour vous faire comprendre ces exemples mis en œuvre dans Ubuntu 20.04.