嵌入式Linux：线程的创建、终止、回收、取消和分离

点击上方蓝色字体，关注我们

线程的创建、终止、取消、回收和分离操作是多线程编程的核心。

在多线程编程中，需要妥善管理线程的生命周期，以避免资源泄漏、竞争条件或僵尸线程等问题。

在 Linux 中，默认情况下，一个进程启动时是单线程运行的，这个线程被称为 主线程。

然而，现代计算任务通常需要并行处理，主线程可以通过 pthread_create() 函数创建额外的线程来并行执行任务。

这些额外的线程与主线程共享进程的资源（如内存空间、文件描述符等），但它们有独立的执行路径。

pthread_create() 函数的定义如下：

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,                   void *(*start_routine) (void *), void *arg);

函数参数：

void* (*start_routine)(void *arg);

它接收一个 void* 类型的参数（arg），并返回一个 void* 类型的返回值。

返回值：

创建线程的关键点：

当一个新线程被创建后，它立即加入系统的 线程调度队列，并在合适的时机获取 CPU 执行时间。

由于调度是由操作系统控制的，所以无法预料新创建的线程和主线程谁会先执行。

如果程序对线程的执行顺序有严格要求，可以使用同步机制（如 互斥锁 或 信号量）来控制线程间的执行顺序。

下面是一个创建线程并传递参数的简单示例：

void* thread_function(void* arg) {    int* num = (int*)arg;    printf("New thread running with argument: %d\n", *num);    return NULL;}
int main() {    pthread_t thread;    int arg = 42;
    // 创建线程，传递参数 arg    if (pthread_create(&thread, NULL, thread_function, &arg) != 0) {        perror("pthread_create failed");        return 1;    }
    // 等待新线程执行完毕    pthread_join(thread, NULL);
    printf("Main thread finished\n");    return 0;}

解释：

在 Linux 中，终止线程可以通过多种方式完成，不同的方式影响线程的退出行为和进程的状态管理。

我们详细说明几种终止线程的常用方法。

线程的 start 函数（即传递给 pthread_create() 的函数）在执行完毕时，可以直接使用 return 语句返回。这种方式会使线程正常退出，并将返回值作为线程的退出码。

这与调用 pthread_exit() 类似。

void* thread_function(void* arg) {    // 执行一些任务    int result = 42;    return (void*)result; // 通过 return 语句退出线程}

在上面的代码中，线程执行完 thread_function() 后，通过 return 返回 result，并且这个返回值可以通过 pthread_join() 函数在主线程中获取。

pthread_exit() 是专门用于退出线程的函数，它允许线程在任何位置显式退出，而不是依赖于 return。

调用 pthread_exit() 后，线程的控制流会立即结束，不再执行后续代码。

pthread_exit() 函数原型：

void pthread_exit(void *retval);

参数 retval: retval 是一个 void* 类型的指针，指定线程的返回值，也就是线程的退出码。这个值可以被其他线程通过 pthread_join() 获取。

示例如下：

void* thread_function(void* arg) {    int* retval = (int*)arg;    printf("Thread exiting with value: %d\n", *retval);    pthread_exit(retval); // 显式退出线程并返回值}
int main() {    pthread_t thread;    int arg = 42;    int* retval;
    pthread_create(&thread, NULL, thread_function, &arg);    pthread_join(thread, (void**)&retval); // 获取线程的退出码
    printf("Thread returned: %d\n", *retval);    return 0;}

解释：

exit()、_exit() 和 _Exit() 不是用于终止单个线程的，而是用于终止整个进程。

由于线程共享同一个进程资源，如果任意一个线程调用这些函数，整个进程（包括所有线程）都会终止。

以下示例中，thread_function() 中调用了 exit()，导致整个进程被终止，主线程也不会继续执行。

void* thread_function(void* arg) {    printf("Thread running...\n");    exit(0); // 调用 exit()，导致整个进程终止    return NULL;}
int main() {    pthread_t thread;
    pthread_create(&thread, NULL, thread_function, NULL);    pthread_join(thread, NULL);
    // 如果没有被 exit() 终止，主线程会继续执行这行代码    printf("Main thread finished\n");
    return 0;}

在多线程编程中，当线程结束后，其占用的资源不会立即被系统释放，除非显式回收这些资源，否则这些线程会变成 僵尸线程。

在 Linux 中，回收线程的操作与进程的回收类似。

正如进程中的父进程可以使用 wait() 来回收子进程的资源，线程中也需要通过 pthread_join() 来回收线程资源并获取线程的退出状态。

pthread_join() 是用于 等待指定线程终止并回收其资源 的函数，它会阻塞调用线程直到目标线程终止。

如果线程已经终止，pthread_join() 将立即返回。

通过这个函数，主线程或其他线程可以获取目标线程的退出状态，并清理其占用的资源，避免产生僵尸线程。

pthread_join() 的函数原型：

int pthread_join(pthread_t thread, void **retval);

函数参数说明：

返回值：

以下例子中，线程执行完 thread_function() 后通过 pthread_exit() 返回 result。

主线程调用 pthread_join() 等待线程结束，并成功获取到了线程的返回值。

void* thread_function(void* arg) {    int result = 100;    printf("Thread running...\n");    pthread_exit((void*)&result); // 显式返回一个结果}
int main() {    pthread_t thread;    int* thread_result;
    // 创建线程    pthread_create(&thread, NULL, thread_function, NULL);
    // 回收线程并获取返回值    pthread_join(thread, (void**)&thread_result);
    printf("Thread returned: %d\n", *thread_result);    return 0;}

pthread_join() 是 阻塞函数，它会一直等待指定线程结束。如果目标线程需要执行大量计算或处理，调用 pthread_join() 的线程将一直处于等待状态，直到目标线程终止。

如果线程已经结束，pthread_join() 将立即返回。

以下示例中，主线程在调用 pthread_join() 时会等待 5 秒，直到 worker_function() 执行完毕为止。

void* worker_function(void* arg) {    sleep(5);  // 模拟一些长时间运行的操作    return NULL;}
int main() {    pthread_t thread;
    pthread_create(&thread, NULL, worker_function, NULL);
    printf("Waiting for thread to finish...\n");    pthread_join(thread, NULL); // 阻塞等待线程结束
    printf("Thread finished.\n");    return 0;}

在进程中，如果父进程不回收子进程，则子进程会变为 僵尸进程，占用系统资源。

同样的，如果一个线程终止后，没有被其他线程调用 pthread_join() 来回收，其内存和其他资源也不会被立即释放，这就导致了 僵尸线程 的问题。

僵尸线程不仅浪费资源，而且如果僵尸线程累积过多，可能会导致应用程序无法创建新的线程。

虽然 pthread_join() 与进程中的 waitpid() 类似，都是用于等待子线程（或子进程）结束并获取其退出状态，但二者之间有一些显著的区别：

在多线程程序中，任何线程都可以调用 pthread_join() 来等待另一个线程的结束。即使是非创建该线程的线程，也可以调用 pthread_join() 来等待它的终止。线程之间没有父子层级关系。

举例来说，如果线程 A 创建了线程 B，线程 B 创建了线程 C，那么线程 A 可以等待线程 C 的结束，而不需要依赖线程 B。

这与进程的父子层级结构不同，父进程是唯一可以调用 wait() 或 waitpid() 来等待子进程终止的进程。

pthread_join() 是阻塞调用，不支持类似waitpid() 中的非阻塞模式（通过传入 WNOHANG 标志实现）。

这意味着线程调用 pthread_join() 后必须等待目标线程终止，不能做其他操作。如果需要更复杂的线程同步，通常需要引入其他机制，如 信号量、条件变量 等。

通常情况下，线程会自行决定何时结束，比如通过调用 pthread_exit() 函数或者在其启动函数中执行 return 语句。

但有些场景下，主线程或其他线程可能需要 强制终止 某个正在运行的线程，这时就可以通过 取消请求 来实现。

通过调用 pthread_cancel()，可以向目标线程发送一个取消请求，要求它终止。

pthread_cancel() 函数原型如下：

int pthread_cancel(pthread_t thread);

参数说明：

返回值：

目标线程对取消请求的响应方式可以由其自身决定。每个线程都有一个 取消状态 和 取消类型 来控制它对取消请求的响应：

取消状态决定了线程是否允许响应取消请求，线程可以通过调用 pthread_setcancelstate() 来修改其取消状态。

pthread_setcancelstate() 函数原型：

int pthread_setcancelstate(int state, int *oldstate);

参数：

示例如下：

pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); // 禁止取消请求pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);  // 允许取消请求

取消类型决定了线程 何时 响应取消请求。

可以通过调用 pthread_setcanceltype() 来设置线程的取消类型：

pthread_setcanceltype() 函数原型：

int pthread_setcanceltype(int type, int *oldtype);

参数：

示例：

pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); // 设置为立即响应取消
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);      // 设置为延迟响应取消

当线程的取消类型设置为 PTHREAD_CANCEL_DEFERRED 时，线程只有在到达某些 取消点 时才会响应取消请求。

取消点通常是一些耗时操作或系统调用，比如：

系统中还有许多函数可以作为取消点，这里不再逐一列举。您可以通过查看 man 手册获取更多信息，使用命令 man 7 pthreads 进行查询。 

pthread_testcancel() 函数原型：

void pthread_testcancel(void);

这个函数可以在代码的任意位置显式创建一个取消点。

调用 pthread_testcancel() 后，线程会检查是否有取消请求，如果有，线程将在此处退出。

示例如下：

while (1) {    // 执行一些任务    pthread_testcancel(); // 在循环中显式设置取消点，检查是否有取消请求}

在线程终止时（无论是正常结束还是被取消），可以使用 清理处理函数 来进行资源清理。

清理处理函数可以确保线程在取消时能够正确释放资源，避免资源泄露。

使用 pthread_cleanup_push() 和 pthread_cleanup_pop() 来设置清理函数：

以下例子中，当线程收到取消请求后，它会在 pthread_testcancel() 函数处响应取消请求并退出。

在线程退出时，cleanup_handler() 会被调用以清理资源。

void cleanup_handler(void *arg) {    printf("Cleanup: %s\n", (char *)arg);}
void* thread_function(void* arg) {    pthread_cleanup_push(cleanup_handler, "Thread resources"); // 设置清理函数    while (1) {        printf("Thread running...\n");        sleep(1);        pthread_testcancel(); // 检查是否有取消请求    }    pthread_cleanup_pop(1); // 1 表示执行清理函数    return NULL;}
int main() {    pthread_t thread;    pthread_create(&thread, NULL, thread_function, NULL);
    sleep(3);  // 等待几秒钟    pthread_cancel(thread); // 发送取消请求    pthread_join(thread, NULL); // 等待线程结束    printf("Thread has been canceled.\n");
    return 0;}

正确处理线程的取消操作对于复杂的多线程应用程序至关重要，特别是在执行长时间任务时，灵活管理线程的取消状态和清理行为能够有效提高系统的稳定性和可靠性。

默认情况下，线程终止后，其资源不会立即被系统回收，除非有另一个线程通过 pthread_join() 函数显式地等待该线程终止，回收其资源。

但如果某些线程的退出状态和返回值对程序来说并不重要，且不希望手动调用 pthread_join()，可以将该线程设置为 分离状态。

分离状态的线程在终止时，系统会自动回收它的资源。

要将线程设置为分离状态，可以调用 pthread_detach() 函数。

pthread_detach() 函数原型：

int pthread_detach(pthread_t thread);

参数说明：

调用 pthread_detach() 后，指定的线程会进入分离状态。

处于分离状态的线程在终止时，系统会自动回收其所有资源，而无需其他线程显式调用 pthread_join()。

分离状态是不可逆的，一旦线程被分离，就不能再通过 pthread_join() 获取该线程的返回状态或等待其结束。

以下例子中，创建了一个新线程，并通过 pthread_detach() 将其分离。之后，无需调用 pthread_join()，系统将在该线程终止时自动回收它的资源。

pthread_t thread;pthread_create(&thread, NULL, thread_function, NULL);pthread_detach(thread); // 将该线程设置为分离状态

线程不仅可以由其他线程分离，还可以通过调用 pthread_detach(pthread_self()) 来 分离自己。

这意味着该线程在终止时不需要其他线程来回收资源，系统将自动处理。

示例如下：

void* thread_function(void* arg) {    pthread_detach(pthread_self()); // 分离自己    // 线程执行的其他操作    pthread_exit(NULL);}

线程分离机制特别适用于以下几种场景：

线程分离与 pthread_join() 的比较：

线程分离:

pthread_join():

线程分离在简化多线程程序的资源管理方面非常有用，特别是对于一些无需等待或回收的线程，可以通过分离机制优化程序的性能和稳定性。

最后讲两点注意事项：

点击阅读原文，更精彩~