How to safely close threads in C under Linux

Linux system is an operating system that supports concurrent execution of multi-tasks. It can run multiple processes at the same time, thereby improving system utilization and efficiency. However, if there are multiple threads in a process, and these threads need to terminate or exit under certain circumstances, you need to pay attention to the safe shutdown of threads. If the thread is not closed correctly, it may cause thread resource leaks, such as memory, file descriptors, semaphores, etc., thus affecting the performance and stability of the system. This article will introduce how to safely shut down threads in C under Linux, including thread termination methods, termination functions, cleanup functions and return values.

Foreword:

In multi-threaded programs, especially when applying frequently and releasing threads, you must pay attention to closing the thread, and it is best to use a thread pool.

1. Thread exit method

(1) Exit implicitly after execution is completed;

(2) The thread itself explicitly calls the pthread_exit function to exit;
pthread_exit (void * retval) ;

(3) Terminated by other threads using pthread_cance function:
pthread_cance (pthread_t thread) ;

2, thread status

pthread threads have two states, joinable (non-detached) state and detachable (detached) state. The default is joinable.
joinable: When the thread function returns and exits by itself or pthread_exit, the resources used by the thread will not be released, including stacks, thread descriptors, etc. (some people say there are more than 8k, but this has not been verified).
detachable: Resources will be automatically released when the thread ends.

Linux man page said:
When a joinable thread terminates, its memory resources (thread descriptor and stack) are not deallocated until another thread performs pthread_join on it. Therefore, pthread_join must be called once for each joinable thread created to avoid memory leaks.

Therefore, if pthread_join is not used after the joinable thread is executed, it will cause a memory leak.

Solution:
1.//Set the PTHREAD_CREATE_DETACHED attribute before creating the thread
pthread_attr_t attr;
pthread_t thread;
pthread_attr_init (&attr);
pthread_attr_setdetachstat(&attr, PTHREAD_CREATE_DETACHED);
pthread_create (&thread, &attr, &thread_function, NULL);
pthread_attr_destroy (&attr);

2. When the thread is joinable, use pthread_join to obtain the thread return value and release resources.

3. When the thread is joinable, you can also call pthread_detach(pthread_self()); in the thread to detach yourself.

This article introduces how to safely shut down threads in C under Linux, including thread termination methods, termination functions, cleanup functions and return values. By understanding and mastering this knowledge, we can better realize the safe shutdown of threads, thereby avoiding the problem of thread resource leakage. Of course, there are many other details and techniques on how to safely close threads in C under Linux, which require continuous learning and practice. I hope this article can bring you some inspiration and help.

The above is the detailed content of How to safely close threads in C under Linux. For more information, please follow other related articles on the PHP Chinese website!