Pthread_function dans le langage C

La norme POSIX nous donne la possibilité de développer des programmes multithread dans la langue C. Cette technique de programmation consiste à utiliser la bibliothèque «pthread» pour ouvrir un ou plusieurs threads de sous-processus qui s'exécutent en parallèle avec le processus principal.

La mise en œuvre de threads apporte de grands avantages au programme final car il accélère les temps d'exécution en exécutant plusieurs tâches simultanément, peut être mieux structuré et fait mieux usage des ressources système.

Un thread est créé avec la fonction pthread_ create (). Une fois cette fonction appelée, le thread commence à fonctionner en parallèle avec le processus principal. Lorsque cette fonction est appelée, il renvoie l'ID de thread dans le thread d'argument de sortie. Cet identifiant est utilisé pour faire référence au thread créé lorsque vous utilisez les fonctions de gestion de thread comme pthread_join () ou pthread_cancel ().

Dans cet article de Linux Hint, vous apprendrez à utiliser la fonction PTHEAD_CANCEL (), l'une des fonctions de gestion des threads C qui vous permet d'annuler un thread qui est déjà en cours d'exécution.

Syntaxe de la fonction pthread_cancel () dans le langage C

int pthread_cancel (thread pthread_t);

Description de la fonction pthread_cancel () dans le langage C

La fonction pthread_cancel () envoie une demande au système pour annuler le thread spécifié par l'identifiant dans son thread d'argument d'entrée.

L'appel à la fonction pthread_cancel () n'implique pas la terminaison immédiate du thread, mais une demande de le faire. Si un thread est terminé après avoir appelé cette fonction dépend des attributs qui lui sont affectés lorsqu'il est créé. Si un thread est créé avec ses attributs par défaut, il peut être annulé.

Les attributs d'annulation d'un thread peuvent être récupérés avec la fonction pthread_setcancelstate () et peuvent être définis avec PTHEAD_SETCANCELTYPE ().

Si la fonction pthread_cancel () est réussie, il renvoie 0 comme le résultat. S'il échoue, il renvoie une valeur non nulle.

La fonction pthread_cancel () de la bibliothèque Pthread est définie dans le «thread.en-tête h ”. Pour utiliser cette fonction et les autres fonctions de gestion de threads, vous devez inclure cet en-tête dans votre programme comme suit:

#inclure

Les programmes qui utilisent les fonctions de gestion de thread doivent être compilés en appelant la bibliothèque de threads à partir de la ligne de commande Linux. Sinon, les erreurs se produiront.

Ce qui suit est une section spéciale qui explique comment compiler correctement les programmes qui utilisent les fonctions de la bibliothèque thread.

Comment annuler un thread en cours d'exécution à l'aide de la fonction pthread_cancel () dans le langage C

Dans cet exemple, nous créons un thread avec la fonction pthread_create (), puis l'annuons au milieu de l'exécution avec la fonction PTHEAD_CANCEL ().

Pour ce faire, nous créons le thread «Thread_1» qui exécute la fonction th_function () qui se compose d'une boucle pour 10 cycles, chacune imprime le "Les secondes du thread init et le nombre de secondes se sont écoulées" phrase dans la console de commande. Après cela, un délai de 1 seconde est inséré pour répéter le cycle. Ainsi, le temps d'exécution du fil est d'environ 10 secondes.

Une fois que Thread_1 est créé et en cours d'exécution, nous introduisons un retard de 5 secondes via la fonction Main () et terminons le sous-processus après la moitié du temps d'exécution. Pour terminer le thread, nous appelons la fonction pthread_cancel () et passons l'identificateur thread_1 qui est renvoyé par la fonction PTHEAD_CREATE () comme argument d'entrée lorsque le thread est créé. Maintenant, regardons le code de cet exemple:

#inclure
#inclure
#inclure
#inclure
void * th_function (void * n);
vide main ()

pthread_t thread_1;
pthread_create (& thread_1, null, & th_function, null);
sommeil (5);
pthread_cancel (thread_1);
sommeil (5);

/ ************************************************* ***** /
void * th_function (void * n)

pour (int sec = 0; sec!= 10; sec ++)

printf ("secondes à partir du thread init% i \ n", sec);
sommeil (1);

L'image suivante montre la compilation et l'exécution du code. Comme vous pouvez le voir, le thread est terminé avec la fonction pthread_cancel () au milieu de l'exécution ou 5 secondes après le début:

Dans ce cas, le thread accepte l'annulation car ses attributs sont définis sur la valeur par défaut à la création en spécifiant un pointeur nul dans les arguments d'entrée «att» de la fonction pthread_create ().

Erreurs dans l'utilisation de la fonction pthread_cancel (): qu'est-ce qu'ils sont et comment les identifier

La manière de déterminer si une erreur se produit lors de l'appel de cette fonction est d'utiliser une condition «IF» où la condition d'entrée est un résultat de retour non nul. Ce qui suit est un extrait de code en utilisant cette méthode de détection d'erreur:

if (pthread_cancel (thread) != 0)
printf ("Une erreur s'est produite en essayant d'annuler le thread spécifié");

La seule erreur que cette fonction peut générer est celle qui est définie comme ISRCH dans le «Errno.en-tête h ”. Cette erreur est générée lorsqu'un thread inexistant est référencé dans l'argument d'entrée de la fonction pthread_cancel ().

Erreurs de compilation dans les programmes avec des threads

Lors de la compilation des programmes GCC qui utilisent des threads, la compilation peut échouer si elle n'est pas effectuée correctement à partir de la ligne de commande.

Le message d'erreur le plus courant émis par le compilateur indique que l'une des fonctions de thread auxquelles nous nous référons dans le code n'est pas définie.

Ces erreurs entraînent souvent un temps précieux en vérifiant les en-têtes que nous avons insérés dans le code, leur intégrité et les répertoires associés au compilateur car tout indique que le problème est là.

Bien que les fonctions qui provoquent l'erreur soient définies dans le «Pthread.h ” en-tête et sont inclus dans le code, le compilateur ne reconnaît pas ces fonctions à moins que la bibliothèque Pthread ne soit appelée à partir de la ligne de commande pendant la compilation.

Vous pouvez voir dans Green la bonne façon d'appeler la bibliothèque Pthread à partir de la console de commande lors de la compilation de programmes avec des threads dans ce qui suit:

~ $ gcc -pthread path / nom de fichier.c -o out_name

Comme nous pouvons le voir dans la figure suivante, l'erreur disparaît lorsque la bibliothèque Pthread est appelée pendant la compilation:

Conclusion

Dans cet article de Linux Hint, nous vous avons montré comment utiliser la fonction PTHEAD_CANCEL () pour demander au système de terminer un thread en cours d'exécution.

Nous avons examiné une description théorique de cette fonction et vous a montré sa syntaxe, les arguments d'entrée et de sortie et le type de données que chacun accepte. Après cela, nous avons mis en œuvre ce que nous avons appris à travers un exemple pratique avec des extraits de code et des images où nous avons vu comment la fonction PTHREAD_CANCEL () fonctionne dans la langue C.

Nous avons également ajouté une section spéciale où nous vous avons montré comment compiler correctement les programmes qui contiennent les threads et les fonctions de la bibliothèque Pthread.