Linux--Control and separation of threads

1. The concept of thread
A thread is a basic execution flow within a process and an entity scheduled by the system. Processes are exclusive and threads are shared. Each thread shares the process's file descriptor, signal processing method, current working directory, user id (uid) and group id (gid). However, some resources are private to threads, such as thread id, stack space, context (including the values ​​of various registers, program counter and stack pointer), space, signal mask words, and scheduling priority. Just like if the process is a family, the threads are the members of the family. Each family member has a common space (dining room, living room). Of course, each family member also has his or her own private space.

2. Thread control
Creation and termination of threads
Create with function pthread_create(), return 0 if successful, and error number if failed. After calling pthread_create() to create a new thread. The current thread returns from pthread_create() and continues execution. The code executed by the new thread is determined by the function pointer start_routine. The function start_routine function receives a parameter, which is passed to it through the arg of pthread_create(). The type is void*, and the return value type of start_toutine is also void*. After start_toutine returns, this thread exits, and other threads can call pthread_join() to get the return value of start_toutine. The start_toutine function can be terminated by ① 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 }

It can be seen that:
1. If returned through return. The value received by pthread_join is the return value of the thread

2. If the thread is abnormally terminated by calling pthread_cancel by another thread. The error code

3 is returned. If it is terminated by calling pthread_exit. pthread_join stores the parameters passed to pthread_exit.

4. The thread numbers of the two threads are different

3. Thread separation
Threads at any point in time. Is joinable or detached. Associable threads can be reclaimed and killed by other threads. Its memory resources are not released before being recycled by other threads. A detachable thread cannot be recycled or killed by others, and its memory resources are automatically released by the system when it terminates. by default. Threads are created to be associative. To avoid memory leaks, each joinable thread should be either explicitly reclaimed by calling pthread_join or detached via the pthread_detach function.
If a combineable thread ends but is not pthread_joined, its status is similar to a zombie process in the process, that is, some resources have not been recycled, so the thread creator should call pthread_join to wait for the thread to end. And can get the exit code of the thread and recycle its resources. After calling pthread_join, if the thread does not end, the caller will be blocked. This can be done by adding the code pthread_detach(pthread_self()) to the child thread or the parent thread calling pthread_detach(thread_id) to be non-blocking and return immediately. This sets the state of the child thread to detached, so that all resources are automatically released when the thread finishes running.

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 }

If you comment out pthread_detach(pthread_self()) in the child thread, the results will be as follows. This is because after detaching the child thread, other threads can Join and kill the child thread process, and then release the memory resources. The above is because it has been separated in the child process, so other threads can no longer access it. Join returns fail

Summary:
Thread control starts from creation Threads-->Three termination methods of child threads-->Other threads join the thread. Depending on the termination method, the return value of join will be different. For thread separation, if pthread_detach() is added to the sub-thread, the sub-thread will be set as a detachable thread. After the thread exits, the memory resources will be automatically released without causing memory leaks. If not set, you need to use join to display the reception and then release the resources, which will not cause memory leaks.

The above is the content of Linux-thread control and separation. For more related content, please pay attention to the PHP Chinese website (m.sbmmt.com)!