Linux – Kontrolle und Trennung von Threads

1. Das Konzept des Threads
Ein Thread ist ein grundlegender Ausführungsablauf innerhalb eines Prozesses und eine Einheit der Systemplanung. Prozesse sind exklusiv und Threads werden gemeinsam genutzt. Jeder Thread teilt den Dateideskriptor, die Signalverarbeitungsmethode, das aktuelle Arbeitsverzeichnis, die Benutzer-ID (uid) und die Gruppen-ID (gid) des Prozesses. Einige Ressourcen sind jedoch für Threads privat, z. B. Thread-ID, Stapelspeicherplatz, Kontext (einschließlich der Werte verschiedener Register, Programmzähler und Stapelzeiger), Speicherplatz, Signalmaskenwort und Planungspriorität. Genauso wie wenn es sich bei dem Prozess um eine Familie handelt, sind die Fäden die Mitglieder der Familie. Jedes Familienmitglied hat einen gemeinsamen Raum (Esszimmer, Wohnzimmer). Natürlich hat jedes Familienmitglied auch seinen eigenen privaten Bereich.

2. Thread-Steuerung
Threads erstellen und beenden
Verwenden Sie die Funktion pthread_create(), um einen Thread zu erstellen. Sie gibt 0 bei Erfolg und eine Fehlernummer zurück, wenn sie fehlschlägt. Nach dem Aufruf von pthread_create() wird ein neuer Thread erstellt. Der aktuelle Thread kehrt von pthread_create() zurück und setzt die Ausführung fort. Der vom neuen Thread ausgeführte Code wird durch den Funktionszeiger start_routine bestimmt. Die Funktion start_routine empfängt einen Parameter, der über das Argument von pthread_create() an sie übergeben wird. Der Typ ist void*, und der Rückgabewerttyp von start_toutine ist ebenfalls void*. Nach der Rückkehr von start_toutine wird dieser Thread beendet und andere Threads können pthread_join() aufrufen, um den Rückgabewert von start_toutine abzurufen. Die Funktion start_toutine kann durch ① return (void*), ② pthread_exit (void*), ③ pthread_cancel (pthread_self ()) beendet werden.

 #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 }

Es ist ersichtlich, dass:
1. Bei Rückgabe durch Rückgabe. Der von pthread_join empfangene Wert ist der Rückgabewert des Threads

2. Wenn der Thread durch den Aufruf von pthread_cancel durch einen anderen Thread abnormal beendet wird. Der Fehlercode

wird zurückgegeben. 3. Wenn es durch den Aufruf von pthread_exit beendet wird. pthread_join speichert die an pthread_exit übergebenen Parameter.

Die Thread-Nummern der beiden Threads sind unterschiedlich

3.Thread-Trennung
Threads zu jedem Zeitpunkt. Ist verbindbar oder abtrennbar. Zuordenbare Threads können von anderen Threads zurückgefordert und beendet werden. Seine Speicherressourcen werden erst freigegeben, wenn sie von anderen Threads recycelt werden. Ein abnehmbarer Thread kann nicht recycelt oder von anderen beendet werden, und seine Speicherressourcen werden vom System automatisch freigegeben, wenn er beendet wird. Standardmäßig. Threads werden assoziativ erstellt. Um Speicherlecks zu vermeiden, sollte jeder verknüpfbare Thread entweder explizit durch Aufruf von pthread_join zurückgefordert oder über die Funktion pthread_detach getrennt werden.
Wenn ein kombinierbarer Thread endet, aber nicht pthread_joined ist, ähnelt sein Status einem Zombie-Prozess im Prozess, das heißt, einige Ressourcen wurden nicht recycelt, daher sollte der Thread-Ersteller pthread_join aufrufen, um auf das Ende des Threads zu warten. Und kann den Exit-Code des Threads abrufen und seine Ressourcen recyceln. Wenn der Thread nach dem Aufruf von pthread_join nicht endet, wird der Aufrufer blockiert. Dies kann durch Hinzufügen des Codes pthread_detach(pthread_self()) zum untergeordneten Thread oder durch Aufrufen des übergeordneten Threads mit pthread_detach(thread_id) erreicht werden, um nicht blockierend zu sein und sofort zurückzukehren. Dadurch wird der Status des untergeordneten Threads auf „getrennt“ gesetzt, sodass alle Ressourcen automatisch freigegeben werden, wenn die Ausführung des Threads beendet ist.

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 }

Wenn Sie pthread_detach(pthread_self()) im Unterthread auskommentieren, sieht das Ergebnis wie folgt aus. Dies liegt daran, dass nach dem Trennen des Unterthreads , andere Threads Sie können dem untergeordneten Thread-Prozess beitreten und ihn beenden und dann die Speicherressourcen freigeben. Das Obige liegt daran, dass es im untergeordneten Prozess getrennt wurde, sodass andere Threads nicht mehr darauf zugreifen können. Join-Returns schlagen fehl

Zusammenfassung:
Die Thread-Steuerung beginnt mit der Erstellung Threads -> Drei Beendigungsmethoden für untergeordnete Threads -> Andere Threads treten dem Thread bei. Abhängig von der Beendigungsmethode ist der Rückgabewert von Join unterschiedlich. Wenn zur Thread-Trennung pthread_detach() zum Sub-Thread hinzugefügt wird, wird der Sub-Thread als abnehmbarer Thread festgelegt. Nach dem Beenden des Threads werden die Speicherressourcen automatisch freigegeben, ohne dass es zu Speicherverlusten kommt. Wenn dies nicht festgelegt ist, müssen Sie Join verwenden, um den Empfang anzuzeigen und dann die Ressourcen freizugeben, was keine Speicherverluste verursacht.

Das Obige ist der Inhalt der Linux-Thread-Steuerung und -Trennung. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!