Linux--Contrôle et séparation des threads

1. Le concept de thread
Un thread est un flux d'exécution de base au sein d'un processus et une entité de planification du système. Les processus sont exclusifs et les threads sont partagés. Chaque thread partage le descripteur de fichier du processus, la méthode de traitement du signal, le répertoire de travail actuel, l'identifiant utilisateur (uid) et l'identifiant de groupe (gid). Cependant, certaines ressources sont privées pour les threads, telles que l'identifiant du thread, l'espace de pile, le contexte (y compris les valeurs de divers registres, le compteur de programme et le pointeur de pile), l'espace, les mots de masque de signal et la priorité de planification. Tout comme si le processus était une famille, les fils sont les membres de la famille. Chaque membre de la famille dispose d'un espace commun (salle à manger, salon). Bien entendu, chaque membre de la famille dispose également de son propre espace privé.

2. Contrôle des threads
Création et terminaison des threads
Utilisez la fonction pthread_create() pour créer un thread. Elle renvoie 0 en cas de succès et un numéro d'erreur en cas d'échec. Après avoir appelé pthread_create() pour créer un nouveau thread. Le thread actuel revient de pthread_create() et continue son exécution. Le code exécuté par le nouveau thread est déterminé par le pointeur de fonction start_routine. La fonction start_routine reçoit un paramètre qui lui est transmis via l'argument de pthread_create(). Le type est void* et le type de valeur de retour de start_toutine est également void*. Après le retour de start_toutine, ce thread se termine et d'autres threads peuvent appeler pthread_join() pour obtenir la valeur de retour de start_toutine. La fonction start_toutine peut être terminée par ① return (void*), ② pthread_exit (void*), ③ pthread_cancel (pthread_self ()).

 #include<stdio.h>  
  2 #include<pthread.h>  
  3 void * thread_run(void* arg)  
  4 {  
  5     int count=5;  
  6     while(1)  
  7     {  
  8         printf("this is a thread,thread id is\n"pthread_self());  
  9         sleep(1);  
 10     }  
 11     //return (void*)1;  
 12     //pthread_exit((void*)2);  
 13     // pthread_cancel(pthread_self());  
 14 }  
 15 int main()  
 16 {  
 17     pthread_t id;  
 18     int ret=pthread_create(&id,NULL,thread_run,NULL);  
 19     int count=10;  
 20     while(count-->0)  
 21     {  
 22         printf("this is a main thread,thread id is %u\n",pthread_self());  
 23         sleep(1);  
 24     }  
 25     void * ted=0;  
 26     pthread_cancel(id);  
 27     pthread_join(id,&ted);  
 28     printf("return success %d\n",(int)ted);  
 29 }

On voit que :
1 Si retourné par retour. La valeur reçue par pthread_join est la valeur de retour du thread

2. Si le thread se termine anormalement en appelant pthread_cancel par un autre thread. Le code d'erreur

est renvoyé 3. S'il est terminé en appelant pthread_exit. pthread_join stocke les paramètres passés à pthread_exit.

4. Les numéros de fil des deux fils sont différents

3. Séparation des fils
Les fils à tout moment. Est joignable ou détaché. Les threads associables peuvent être récupérés et supprimés par d'autres threads. Ses ressources mémoire ne sont pas libérées avant d'être recyclées par d'autres threads. Un thread détachable ne peut pas être recyclé ou supprimé par d'autres, et ses ressources mémoire sont automatiquement libérées par le système lorsqu'il se termine. Par défaut. Les fils de discussion sont créés pour être associatifs. Pour éviter les fuites de mémoire, chaque thread joignable doit être soit explicitement récupéré en appelant pthread_join, soit détaché via la fonction pthread_detach.
Si un thread combinable se termine mais n'est pas pthread_joined, son statut est similaire à celui d'un processus zombie dans le processus, c'est-à-dire que certaines ressources n'ont pas été recyclées, le créateur du thread doit donc appeler pthread_join pour attendre la fin du thread. Et peut obtenir le code de sortie du thread et recycler ses ressources. Après avoir appelé pthread_join, si le fil de discussion ne se termine pas, l'appelant sera bloqué. Cela peut être fait en ajoutant le code pthread_detach(pthread_self()) au thread enfant ou au thread parent appelant pthread_detach(thread_id) pour être non bloquant et revenir immédiatement. Cela définit l'état du thread enfant sur détaché, de sorte que toutes les ressources soient automatiquement libérées lorsque le thread termine son exécution.

1 #include<stdio.h>  
  2 #include<pthread.h>  
  3 void* thread_run(void* arg)  
  4 {  
  5     pthread_detach(pthread_self()); //分离线程  
  6     printf("this is a thrad \n");  
  7     return (void*)1;  
  8 }  
  9 int main()  
 10 {  
 11     pthread_t id;  
 12     int ret= pthread_create(&id,NULL,thread_run,NULL);  
 13     printf("this is a main thread\n");  
 14     sleep(1);  
 15   
 16     int res=pthread_join(id,NULL);  
 17     if(res==0)  
 18     {  
 19         printf("pthrad wait succced\n");  
 20         return 0;  
 21     }  
 22     else  
 23     {  
 24         printf("pthread wait faile\n");  
 25         return 1;  
 26     }  
 27     return 0;  
 28 }

Si vous commentez pthread_detach(pthread_self()) dans le sous-thread, le résultat sera le suivant car après avoir détaché le sous-thread. , d'autres threads Vous pouvez rejoindre et tuer le processus du thread enfant, puis libérer les ressources mémoire. Ce qui précède est dû au fait qu'il a été séparé dans le processus enfant, de sorte que les autres threads ne peuvent plus y accéder. La jointure renvoie un échec

Résumé :
Le contrôle des threads commence dès la création. Threads-->Trois méthodes de terminaison des threads enfants-->D'autres threads rejoignent le thread. Selon la méthode de terminaison, la valeur de retour de join sera différente. Pour la séparation des threads, si pthread_detach() est ajouté au sous-thread, le sous-thread sera défini comme un thread détachable après la sortie du thread, les ressources mémoire seront automatiquement libérées sans provoquer de fuites de mémoire. S'il n'est pas défini, vous devez utiliser join pour afficher la réception, puis libérer les ressources, ce qui ne provoquera pas de fuite de mémoire.

Ce qui précède est le contenu du contrôle et de la séparation des threads Linux. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !