Comment fermer en toute sécurité les threads en C sous Linux

Le système Linux est un système d'exploitation qui prend en charge l'exécution simultanée de tâches multiples. Il peut exécuter plusieurs processus en même temps, améliorant ainsi l'utilisation et l'efficacité du système. Cependant, s'il y a plusieurs threads dans un processus et que ces threads doivent se terminer ou se fermer dans certaines circonstances, vous devez faire attention à l'arrêt en toute sécurité des threads. Si le thread n'est pas fermé correctement, cela peut provoquer des fuites de ressources du thread, telles que la mémoire, les descripteurs de fichiers, les sémaphores, etc., affectant ainsi les performances et la stabilité du système. Cet article explique comment arrêter en toute sécurité les threads en C sous Linux, y compris les méthodes de terminaison de thread, les fonctions de terminaison, les fonctions de nettoyage et les valeurs de retour.

Avant-propos :

Dans les programmes multithread, en particulier lors de l'application et de la publication fréquentes de threads, vous devez faire attention à la fermeture des threads et il est préférable d'utiliser un pool de threads.

1. Méthode de sortie du fil

(1) Quitter implicitement une fois l'exécution terminée ;

(2) Le thread lui-même appelle explicitement la fonction pthread_exit pour quitter

; pthread_exit (void * retval) ;

(3) Terminé par d'autres threads utilisant la fonction pthread_cance :

pthread_cance (fil pthread_t) ;

Deuxièmement, l'état du fil Les threads

pthread ont deux états, l'état joignable (non détaché) et l'état détachable (détaché). La valeur par défaut est joignable. joinable : lorsque la fonction thread revient et se termine d'elle-même ou pthread_exit, les ressources utilisées par le thread ne seront pas libérées, y compris les piles, les descripteurs de thread, etc. (certaines personnes disent qu'il y en a plus de 8k, mais cela n'a pas été vérifié) .
détachable : les ressources seront automatiquement libérées à la fin du fil de discussion.

La page de manuel Linux disait :

Lorsqu'un thread joignable se termine, ses ressources mémoire (descripteur de thread et pile) ne sont pas libérées jusqu'à ce qu'un autre thread exécute pthread_join dessus. Par conséquent, pthread_join doit être appelé une fois pour chaque thread joignable créé pour éviter les fuites de mémoire.

Par conséquent, si pthread_join n'est pas utilisé après l'exécution du thread joignable, cela provoquera une fuite de mémoire.

Solution :

1.//Définissez l'attribut PTHREAD_CREATE_DETACHED avant de créer le fil de discussion
pthread_attr_t attr;
fil de discussion pthread_t ;
pthread_attr_init (&attr);
pthread_attr_setdetachstat(&attr, PTHREAD_CREATE_DETACHED);
pthread_create (&thread, &attr, &thread_function, NULL);
pthread_attr_destroy (&attr);

2. Lorsque le thread peut être rejoint, utilisez pthread_join pour obtenir la valeur de retour du thread et libérer les ressources.

3. Lorsque le fil est joignable, vous pouvez également appeler pthread_detach(pthread_self()); dans le fil pour vous détacher.

Cet article explique comment arrêter en toute sécurité les threads en C sous Linux, y compris les méthodes de terminaison de thread, les fonctions de terminaison, les fonctions de nettoyage et les valeurs de retour. En comprenant et maîtrisant ces connaissances, nous pouvons mieux mettre en œuvre un arrêt sûr des threads, évitant ainsi le problème de fuite de ressources de thread. Bien sûr, il existe de nombreux autres détails et techniques sur la façon de fermer des threads en toute sécurité en C sous Linux, qui nécessitent un apprentissage et une pratique continus. J'espère que cet article pourra vous apporter de l'inspiration et de l'aide.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!