Linux 线程控制

POSIX 线程库
- 使用 pthread 注意事项
pthread_create 函数：线程创建
pthread_exit 函数：线程终止
pthread_cancel 函数：线程取消
pthread_cleanup_push 和 pthread_cleanup_pop 函数：线程资源清理
pthread_join 函数：线程等待与资源回收
pthread_detach 函数：线程分离
线程局部存储（TLS）技术：__thread 关键字详解

POSIX 线程库

POSIX 线程库（通常称为 pthread）是 UNIX/Linux 系统提供的 多线程编程标准接口，它定义了一套跨平台的线程操作函数，绝大多数函数以 pthread_ 开头

POSIX（Portable Operating System Interface） 是一套操作系统 API 标准，确保程序在不同 UNIX/Linux 系统上的兼容性
pthread 是 POSIX 定义的线程管理库，提供 线程创建、同步、销毁 等功能
几乎所有 Linux/Unix 系统（包括 macOS）都支持 pthread，Windows 可通过 Cygwin、WSL 或第三方库（如 pthreads-win32）兼容

使用 pthread 注意事项

头文件：#include <pthread.h>
编译选项：gcc -lpthread（必须链接 pthread 库，否则会报未定义错误）

`pthread_create` 函数：线程创建

pthread_create 是 POSIX 线程库（pthread）中最重要的函数之一，用于创建一个新的线程它的作用类似于进程中的 fork()，但创建的是更轻量级的线程

函数原型

#include <pthread.h>

int pthread_create(
    pthread_t       *thread,         // 输出参数，返回线程ID
    const pthread_attr_t *attr,     // 线程属性（通常设为NULL）
    void *(*start_routine)(void *), // 线程要执行的函数
    void            *arg            // 传递给线程函数的参数
);

参数说明

参数	类型	说明
`thread`	`pthread_t *`	输出参数，用于存储新线程的 ID（唯一标识）
`attr`	`const pthread_attr_t *`	线程属性（如栈大小、调度策略等），通常设为 `NULL`（使用默认属性）
`start_routine`	`void ()(void *)`	线程入口函数（必须是 `void* func(void*)` 格式）
`arg`	`void *`	传递给 `start_routine` 的参数（可以是任意类型，需强制转换）

返回值

返回值	说明
`0`	成功创建线程
`非0`	失败，返回错误码（如 `EAGAIN` 表示资源不足）

使用示例

（1）传递单个参数

#include <stdio.h>
#include <pthread.h>

// 线程要执行的函数
void* thread_func(void *arg) {
    int num = *(int *)arg;  // 获取参数
    printf("Thread: received %d\n", num);
    return NULL;
}

int main() {
    pthread_t tid;  // 线程ID
    int arg = 123;  // 传递给线程的参数

    // 创建线程
    int ret = pthread_create(&tid, NULL, thread_func, &arg);
    if (ret != 0) {
        perror("pthread_create failed");
        return 1;
    }

    printf("Main thread: created thread %lu\n", (unsigned long)tid);
    pthread_join(tid, NULL);  // 等待线程结束
    return 0;
}

（2）传递多个参数
如果需要传递多个参数，可以用结构体：

#include <stdio.h>
#include <pthread.h>

// 定义参数结构体
struct ThreadArgs {
    int num;
    char *msg;
};

void* thread_func(void *arg) {
    struct ThreadArgs *args = (struct ThreadArgs *)arg;
    printf("Thread: %s, num=%d\n", args->msg, args->num);
    return NULL;
}

int main() {
    pthread_t tid;
    struct ThreadArgs args = {42, "Hello"};  // 初始化参数

    pthread_create(&tid, NULL, thread_func, &args);
    pthread_join(tid, NULL);
    return 0;
}

注意事项

线程函数必须是 void* func(void*) 形式：
- 返回值必须是 void*（可返回 NULL）
- 参数必须是 void*（需强制转换）
线程属性（attr）通常设为 NULL：
- 如果需要调整栈大小、调度策略等，可以使用 pthread_attr_init() 设置
线程结束时必须回收资源：
- 使用 pthread_join() 等待线程结束（否则可能内存泄漏）
- 或者使用 pthread_detach() 让线程自动回收
主线程退出会导致所有线程终止：
- 如果 main() 先退出，子线程可能被强制结束

常见错误

错误	原因	解决方案
`EAGAIN`	系统资源不足（如线程数超限）	减少线程数量或调整系统限制
`EINVAL`	无效的线程属性	检查 `attr` 是否正确初始化
`EPERM`	权限不足（如尝试修改调度策略）	以更高权限运行或调整策略

`pthread_exit` 函数：线程终止

pthread_exit 是 POSIX 线程库（pthread）中用于显式终止当前线程的函数它类似于进程中的 exit()，但仅影响当前线程，而非整个进程

函数原型

#include <pthread.h>

void pthread_exit(void *value_ptr);

参数说明

参数	类型	说明
`value_ptr`	`void *`	线程的返回值（可被其他线程通过 `pthread_join` 获取）注意：必须指向全局变量或堆内存，不能是线程栈上的局部变量！

关键特性

终止当前线程：
- 调用后，当前线程立即结束，但进程不会退出（除非是主线程调用了 pthread_exit）
- 类似于 return，但可以在线程函数的任意位置调用
返回值传递：
- 通过 value_ptr 传递返回值，其他线程可用 pthread_join 接收
- 如果不需要返回值，可传 NULL
资源清理：
- 线程退出时会自动释放栈空间，但不会自动释放其他资源（如动态分配的内存、打开的文件等），需手动管理

使用示例

（1）基本用法

#include <stdio.h>
#include <pthread.h>

void* thread_func(void *arg) {
    printf("Thread is running\n");
    pthread_exit((void *)42);  // 终止线程并返回值
}

int main() {
    pthread_t tid;
    void *ret_val;

    pthread_create(&tid, NULL, thread_func, NULL);
    pthread_join(tid, &ret_val);  // 获取线程返回值

    printf("Thread returned: %ld\n", (long)ret_val);
    return 0;
}

输出：

Thread is running
Thread returned: 42

（2）错误用法（返回局部变量）

void* thread_func(void *arg) {
    int local_var = 42;
    pthread_exit(&local_var);  // 错误！局部变量会被销毁
}

后果：其他线程通过 pthread_join 获取的指针指向无效内存，导致未定义行为

与 `return` 的区别

特性	`pthread_exit`	`return`
调用位置	可在任意函数中调用	只能在线程函数中调用
返回值处理	显式传递返回值	隐式返回（需通过 `return` 语句）
线程栈清理	立即终止，栈空间回收	正常函数返回流程

注意事项

不要返回局部变量的指针：
- 线程栈会在退出后被回收，指向局部变量的指针将失效
- 正确做法：返回 malloc 分配的内存或全局变量
主线程调用 pthread_exit：
- 主线程调用后，进程不会立即退出，直到所有线程结束
- 若主线程直接 return 或调用 exit()，所有线程会被强制终止
与 pthread_join 配合：
- 返回值需通过 pthread_join 获取，否则可能内存泄漏（如果返回的是 malloc 分配的内存）

常见问题

Q1: 为什么不能返回局部变量？

线程栈是线程私有的，退出后栈内存被回收，返回的指针指向无效地址

Q2: 如何安全地返回数据？

方法1：返回全局变量

int global_var = 42;
pthread_exit(&global_var);  // 安全

方法2：返回堆内存（需调用者释放）

int *heap_var = malloc(sizeof(int));
*heap_var = 42;
pthread_exit(heap_var);  // 需在 pthread_join 后 free

Q3: 主线程调用 `pthread_exit` 会怎样？

主线程变为“僵尸线程”，进程继续运行，直到所有线程退出，具体解释如下：

当主线程（即程序初始创建的线程）调用 pthread_exit 退出时，其行为与普通线程调用 pthread_exit 类似，但需要注意以下几点关键影响：

主线程终止，但进程可能继续运行
- 默认情况下，进程会等待所有线程（包括主线程）结束后才退出。如果其他线程仍在运行，进程会继续执行，直到所有线程退出。
- 这与主线程直接 return 或调用 exit 不同：
  - exit 会终止整个进程（包括所有线程）。
  - return 从 main 函数返回时，会隐式调用 exit，导致进程结束。

主线程资源释放
- 主线程的栈和线程描述符会被释放，但进程的全局资源（如堆内存、打开的文件描述符等）会保留，直到进程退出。

返回值处理
- 主线程通过 pthread_exit 传递的返回值（通过 void* 参数）可以被其他线程通过 pthread_join 获取。但如果主线程未被其他线程 join，返回值会被忽略。

潜在风险
- 僵尸进程风险：如果主线程退出后，其他线程因阻塞或死循环无法退出，进程会一直存在，成为“僵尸”。
- 依赖主线程的操作失败：例如，某些GUI框架或库可能要求主线程负责事件循环，主线程退出会导致程序异常。

示例代码

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

void* worker(void* arg) {
    printf("子线程正在运行...\n");
    sleep(2);
    printf("子线程结束\n");
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, worker, NULL);

    printf("主线程调用 pthread_exit\n");
    pthread_exit(NULL); // 主线程退出，但进程继续

    // 以下代码不会执行
    printf("这行不会打印\n");
    return 0;
}

输出：

主线程调用 pthread_exit
子线程正在运行...
子线程结束         # 进程在此后退出

何时使用？

需要让其他线程继续完成任务时，主线程可以调用 pthread_exit 退出。
但更常见的做法是让主线程通过 pthread_join 等待其他线程结束，以保持逻辑清晰。

总结

主线程调用 pthread_exit 会终止自身，但进程会持续到所有线程退出。需谨慎使用，避免资源泄漏或不可控的进程行为。在大多数场景下，显式地管理线程生命周期（如 pthread_join）是更安全的选择。

总结

关键点	说明
功能	显式终止当前线程，并可传递返回值
返回值	必须指向全局变量或堆内存，不能是局部变量
资源管理	不会自动释放非栈资源（如 `malloc` 内存）
与 `return` 区别	`pthread_exit` 可在任意位置调用，`return` 需在函数末尾

正确使用 pthread_exit 可以安全地终止线程并传递数据，但需注意内存管理的陷阱！

`pthread_cancel` 函数：线程取消

pthread_cancel 是 POSIX 线程库中用于请求取消另一个线程的函数它允许一个线程向目标线程发送取消请求，但目标线程是否立即终止取决于其取消状态和类型

函数原型

#include <pthread.h>

int pthread_cancel(pthread_t thread);

参数说明

参数	类型	说明
`thread`	`pthread_t`	目标线程的 ID（通过 `pthread_create` 获取）

返回值

返回值	说明
`0`	取消请求发送成功（不保证线程已终止）
`非0`	失败，返回错误码（如 `ESRCH` 表示线程不存在）

线程取消的工作原理

线程取消是协作式的，目标线程需要响应取消请求才会终止具体行为由两个属性控制：

（1）取消状态（Enable/Disable）**

PTHREAD_CANCEL_ENABLE（默认）：线程可被取消
PTHREAD_CANCEL_DISABLE：忽略取消请求

（2）取消类型（Deferred/Asynchronous）**

PTHREAD_CANCEL_DEFERRED（默认）：延迟取消，线程在到达取消点（如 sleep、read 等系统调用）时终止
PTHREAD_CANCEL_ASYNCHRONOUS：立即取消（危险！可能破坏数据一致性）

函数	说明
`pthread_setcancelstate()`	设置取消状态（Enable/Disable）
`pthread_setcanceltype()`	设置取消类型（Deferred/Asynchronous）
`pthread_testcancel()`	手动插入取消点（检查是否收到取消请求）

使用示例

（1）基本用法

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void* thread_func(void *arg) {
    // 默认情况下，取消请求会在取消点（如sleep）生效
    while (1) {
        printf("Thread is running...\n");
        sleep(1);  // 取消点
    }
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, thread_func, NULL);

    sleep(3);  // 3秒后发送取消请求
    pthread_cancel(tid);

    pthread_join(tid, NULL);
    printf("Thread canceled.\n");
    return 0;
}

输出：

Thread is running...
Thread is running...
Thread is running...
Thread canceled.

（2）禁用取消请求

void* thread_func(void *arg) {
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
    while (1) {
        printf("Thread is running (cancel disabled)...\n");
        sleep(1);
    }
    return NULL;
}

结果：pthread_cancel 调用无效，线程继续运行

*注意事项

资源清理问题：
- 线程被取消时不会自动释放锁或内存，可能导致死锁或泄漏
- 解决方案：使用 清理处理程序（pthread_cleanup_push/pthread_cleanup_pop）
异步取消的风险：
- PTHREAD_CANCEL_ASYNCHRONOUS 可能在线程执行任意指令时终止它，破坏数据一致性
- 仅在绝对必要时使用（如计算密集型且无共享数据的线程）
取消点的限制：
- 如果线程长时间不调用取消点（如纯计算循环），取消请求会延迟生效
- 可手动插入 pthread_testcancel()

常见问题

Q1: 为什么线程没有立即终止？

目标线程可能禁用了取消（PTHREAD_CANCEL_DISABLE），或未到达取消点

Q2: 如何安全地终止线程？

推荐使用协作式取消（通过共享变量通知线程退出循环）

示例：

int thread_running = 1;

void* thread_func(void *arg) {
    while (thread_running) {
        // 正常工作
    }
    return NULL;
}

// 主线程中：
thread_running = 0;  // 通知线程退出
pthread_join(tid, NULL);

Q3: 取消后如何回收资源？

使用清理处理程序：

void cleanup(void *arg) {
    printf("Cleaning up: %s\n", (char *)arg);
    free(arg);
}

void* thread_func(void *arg) {
    char *data = malloc(100);
    pthread_cleanup_push(cleanup, data);
    // 线程工作代码
    pthread_cleanup_pop(1);  // 执行清理
    return NULL;
}

总结

关键点	说明
功能	向目标线程发送取消请求（协作式）
取消控制	通过状态（Enable/Disable）和类型（Deferred/Asynchronous）管理
安全性	默认延迟取消更安全，异步取消需谨慎
资源管理	必须手动处理锁、内存等资源的释放

pthread_cancel 是强制终止线程的最后手段，优先考虑协作式退出机制（如共享标志变量）

`pthread_cleanup_push` 和 `pthread_cleanup_pop` 函数：线程资源清理

这两个函数用于注册和触发线程清理处理程序，确保线程被取消或异常终止时能正确释放资源（如解锁互斥锁、关闭文件、释放堆内存等）它们是 POSIX 线程库中管理资源安全性的关键机制

函数原型

#include <pthread.h>

void pthread_cleanup_push(void (*routine)(void *), void *arg);
void pthread_cleanup_pop(int execute);

核心功能

函数	作用
`pthread_cleanup_push`	注册一个清理函数（如 `free` 或 `pthread_mutex_unlock`）
`pthread_cleanup_pop`	移除最近注册的清理函数，并可选是否立即执行它

触发清理的三种情况

线程调用 pthread_exit 终止
线程被其他线程 pthread_cancel 取消
显式调用 pthread_cleanup_pop(1)（参数为非0）

注意：如果线程通过 return 正常退出，不会触发清理函数！

使用示例

（1）基本用法（释放动态内存）

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>

void cleanup_handler(void *arg) {
    printf("Cleaning up: %s\n", (char *)arg);
    free(arg);  // 释放堆内存
}

void* thread_func(void *arg) {
    char *data = malloc(100);
    sprintf(data, "Thread data");

    // 注册清理函数
    pthread_cleanup_push(cleanup_handler, data);

    // 模拟线程工作（可能被取消）
    while (1) {
        printf("Working with data: %s\n", data);
        sleep(1);
    }

    // 必须成对调用（即使不可达）
    pthread_cleanup_pop(0);  // 0表示不执行，仅出栈
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, thread_func, NULL);

    sleep(3);
    pthread_cancel(tid);  // 触发清理函数
    pthread_join(tid, NULL);
    return 0;
}

输出：

Working with data: Thread data
Working with data: Thread data
Working with data: Thread data
Cleaning up: Thread data  # 线程取消时自动调用清理函数

（2）保护互斥锁（避免死锁）

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void cleanup_unlock(void *arg) {
    pthread_mutex_unlock((pthread_mutex_t *)arg);
}

void* thread_func(void *arg) {
    pthread_mutex_lock(&mutex);
    pthread_cleanup_push(cleanup_unlock, &mutex);

    // 临界区操作（可能被取消）
    printf("Critical section\n");
    sleep(2);

    pthread_cleanup_pop(1);  // 1表示执行清理函数（解锁）
    return NULL;
}

关键注意事项

必须成对使用：
- pthread_cleanup_push 和 pthread_cleanup_pop 必须在同一个作用域内成对出现
- 它们实际上是宏，可能展开为 { 和 }，因此不允许跨函数或条件分支
执行顺序：
- 清理函数按**栈顺序（后进先出）**执行
return 的陷阱：
- 如果线程通过 return 退出，清理函数不会执行！必须用 pthread_exit 或触发取消
与 C++ 析构函数的区别：
- C++ 局部对象的析构函数在线程 return 时仍会调用，但清理函数不会

典型应用场景

场景	清理目标
动态内存管理	`free`、`delete`
文件操作	`fclose`、`close`
锁管理	`pthread_mutex_unlock`、`sem_post`
网络连接	`shutdown`、`close`

常见问题

Q1: 为什么 `pthread_cleanup_pop` 需要参数？

参数控制是否立即执行清理函数：
- pthread_cleanup_pop(1)：执行并移除
- pthread_cleanup_pop(0)：仅移除（不执行）

Q2: 清理函数可以嵌套吗？

可以，按注册的逆序执行：

pthread_cleanup_push(cleanup1, arg1);
pthread_cleanup_push(cleanup2, arg2);
pthread_cleanup_pop(1);  // 执行 cleanup2
pthread_cleanup_pop(1);  // 执行 cleanup1

Q3: 如果线程正常 `return`，如何确保资源释放？

方案1：改用 pthread_exit 退出线程
方案2：在 return 前手动调用清理逻辑（不推荐，易遗漏）

总结

关键点	说明
核心作用	确保线程异常终止时资源不被泄漏
触发条件	`pthread_exit`、`pthread_cancel` 或显式 `pthread_cleanup_pop(1)`
必须成对	严格在相同作用域内匹配使用
执行顺序	后进先出（LIFO）

正确使用这两个函数是编写健壮多线程程序的必备技能！

`pthread_join` 函数：线程等待与资源回收

pthread_join 是 POSIX 线程库中用于等待指定线程终止并回收其资源的关键函数它的作用类似于进程中的 waitpid，但针对的是线程级别的同步

为什么需要线程等待？

（1）资源回收

线程退出后，其占用的栈空间和线程描述符不会自动释放
若不调用 pthread_join，会导致内存泄漏（类似进程的“僵尸线程”问题）

（2）获取返回值

线程可以通过 pthread_exit 或 return 返回数据，pthread_join 是接收这些数据的唯一方式

（3）同步控制

确保主线程等待子线程完成特定任务后再继续执行

函数原型

#include <pthread.h>

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

参数	说明
`thread`	目标线程的 ID（由 `pthread_create` 返回）
`value_ptr`	指向指针的指针，用于接收线程返回值（可设为 `NULL`）

返回值：

0：成功
非零：错误码（如 ESRCH 表示线程不存在）

工作流程

阻塞调用者：当前线程（通常是主线程）进入阻塞状态，直到目标线程结束
回收资源：释放目标线程的栈和线程描述符
获取返回值：如果 value_ptr 非 NULL，存储线程的返回值

使用示例

（1）基本用法（等待线程结束）

#include <stdio.h>
#include <pthread.h>

void* thread_func(void *arg) {
    printf("Thread is working...\n");
    pthread_exit((void *)42);  // 返回整数值
}

int main() {
    pthread_t tid;
    void *ret_val;

    pthread_create(&tid, NULL, thread_func, NULL);
    pthread_join(tid, &ret_val);  // 阻塞等待线程结束

    printf("Thread returned: %ld\n", (long)ret_val);
    return 0;
}

输出：

Thread is working...
Thread returned: 42

（2）忽略返回值

pthread_join(tid, NULL);  // 不关心返回值，仅回收资源

（3）错误处理

if (pthread_join(tid, &ret_val) != 0) {
    perror("pthread_join failed");
    exit(1);
}

关键注意事项

（1）线程必须可连接（Joinable）

默认情况下，线程是 可连接的（Joinable）
若线程被设置为 分离状态（pthread_detach），则不能再调用 pthread_join（否则返回 EINVAL）

（2）返回值的内存管理

如果线程返回的是 malloc 分配的堆内存，调用者需负责释放：

void* thread_func(void *arg) {
    int *result = malloc(sizeof(int));
    *result = 42;
    return result;  // 返回堆内存指针
}

// 主线程中：
int *ptr;
pthread_join(tid, (void **)&ptr);
printf("Result: %d\n", *ptr);
free(ptr);  // 必须手动释放！

（3）禁止重复调用

对同一个线程多次调用 pthread_join 会导致未定义行为

（4）主线程退出问题

如果主线程直接 exit 或 return，所有子线程会被强制终止，可能导致资源泄漏
解决方案：主线程应等待所有子线程结束后再退出

常见问题

Q1: 不调用 `pthread_join` 会怎样？

内存泄漏：线程的栈空间和描述符不会被回收
无法获取返回值：线程的返回数据丢失

Q2: 如何避免阻塞等待？

使用 pthread_detach 让线程自动回收资源（但无法获取返回值）：
```
pthread_detach(tid);  // 线程退出后自动释放资源
```

总结

关键点	说明
核心作用	等待线程终止 + 回收资源 + 获取返回值
资源管理	必须调用以避免内存泄漏
同步控制	确保线程间的执行顺序
返回值	需注意堆内存的释放责任

正确使用 pthread_join 是多线程编程中避免资源泄漏的基础！

`pthread_detach` 函数：线程分离

pthread_detach 是 POSIX 线程库中用于**将线程标记为”分离状态”**的函数，使得线程终止时系统自动回收其资源，无需其他线程调用 pthread_join

为什么需要线程分离？

（1）默认问题

新创建的线程默认是 可连接的（Joinable），必须显式调用 pthread_join 回收资源，否则会导致：
- 内存泄漏：线程栈和描述符未被释放
- 僵尸线程：类似僵尸进程，占用系统资源

（2）分离线程的优势

自动回收资源：线程退出时，系统立即回收其资源
减少同步负担：无需手动调用 pthread_join，适合不关心返回值的场景

函数原型

#include <pthread.h>

int pthread_detach(pthread_t thread);

参数	说明
`thread`	目标线程的 ID（由 `pthread_create` 返回或 `pthread_self()` 获取）

返回值：

0：成功
非零：错误码（如 ESRCH 表示线程不存在，EINVAL 表示线程已分离）

使用方式

（1）其他线程分离目标线程

pthread_t tid;
pthread_create(&tid, NULL, thread_func, NULL);
pthread_detach(tid);  // 主线程分离子线程

（2）线程自我分离

void* thread_func(void *arg) {
    pthread_detach(pthread_self());  // 分离自己
    printf("Thread is running...\n");
    return NULL;
}

关键特性

特性	说明
资源回收	线程退出时自动释放栈和描述符
返回值	分离线程的返回值无法通过 `pthread_join` 获取
不可逆性	一旦分离，不能再调用 `pthread_join`（否则返回 `EINVAL`）
线程安全	可被任意线程（包括自己）调用

使用示例

（1）基础用法

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void* thread_func(void *arg) {
    printf("Thread working...\n");
    sleep(1);
    printf("Thread exiting\n");
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, thread_func, NULL);
    pthread_detach(tid);  // 分离线程

    printf("Main thread continues\n");
    sleep(2);  // 等待子线程退出（实际生产代码应避免sleep）
    return 0;
}

输出：

Main thread continues
Thread working...
Thread exiting  # 线程退出后资源自动回收

（2）错误处理

if (pthread_detach(tid) != 0) {
    perror("pthread_detach failed");
    // 补救措施：尝试 pthread_join
}

注意事项

禁止重复分离：
- 对已分离的线程再次调用 pthread_detach 会返回 EINVAL
与 pthread_join 互斥：
- 分离和连接是互斥操作，一个线程只能选择一种方式
主线程退出问题：
- 即使线程已分离，主线程若直接退出（如调用 exit），仍可能导致子线程被强制终止
返回值限制：
- 分离线程不应返回需要手动释放的堆内存（因为无法通过 pthread_join 获取指针并 free）

常见问题

Q1: 分离线程和守护线程的区别？

分离线程：仅控制资源回收方式，仍是普通线程
守护线程（如 Linux 的 pthread_create + pthread_detach）：常驻后台执行任务，主线程退出时不会影响它（需额外设置）

Q2: 如何判断线程是否已分离？

POSIX 未提供直接接口，需通过返回值推断：
- 调用 pthread_detach 返回 EINVAL 表示已分离
- 调用 pthread_join 返回 EINVAL 也表示已分离

Q3: 分离线程能否取消？

可以，pthread_cancel 对分离线程同样有效

应用场景

场景	理由
后台任务	不依赖主线程，不关心结果（如日志写入）
一次性任务	执行完即销毁，无需跟踪状态
资源受限环境	避免忘记 `pthread_join` 导致泄漏

总结

关键点	说明
核心作用	让线程退出时自动回收资源
资源管理	替代 `pthread_join`，避免手动回收
使用限制	无法获取返回值，不可逆
最佳实践	适用于不关心返回值的异步任务

线程分离是多线程编程中”即用即弃”场景的高效解决方案

线程局部存储（TLS）技术：`__thread` 关键字详解

线程局部存储（Thread-Local Storage, TLS）是一种让每个线程拥有变量独立副本的机制，POSIX 线程库通过 __thread 关键字实现这一功能

为什么需要线程局部存储？

在多线程环境中，全局变量和静态变量被所有线程共享，可能导致：

数据竞争：多个线程同时修改同一变量
逻辑错误：某线程修改全局变量影响其他线程
减少函数传参：对于每一个线程，都有一个属于自己的变量副本，函数内调用别的函数可以直接访问

__thread 为变量提供线程级别的存储周期，每个线程访问的都是自己的独立副本

`__thread` 的基本用法

（1）语法规则

__thread 类型 变量名;

只能修饰 全局变量、静态变量（局部或全局作用域均可），且必须为内置类型
不能修饰函数内的普通局部变量（非静态）

（2）示例代码

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

__thread int tls_var = 0;  // 线程局部存储变量

void* thread_func(void *arg) {
    tls_var = (int)(long)arg;  // 每个线程修改自己的副本
    printf("Thread %ld: tls_var = %d\n", (long)pthread_self(), tls_var);
    return NULL;
}

int main() {
    pthread_t tid1, tid2;
    
    pthread_create(&tid1, NULL, thread_func, (void *)1);
    pthread_create(&tid2, NULL, thread_func, (void *)2);
    
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    
    printf("Main thread: tls_var = %d\n", tls_var);  // 主线程的副本
    return 0;
}

输出：

Thread 1: tls_var = 1
Thread 2: tls_var = 2
Main thread: tls_var = 0  # 主线程的副本未被修改

关键特性

特性	说明
独立性	每个线程持有变量的独立副本
初始化	只能使用常量表达式初始化（如 `__thread int x = 42;`）
作用域	可修饰全局变量或 `static` 局部变量
效率	访问速度与普通全局变量相当（由编译器优化）

与相关技术的对比

技术	作用	区别
`__thread`	线程局部存储	编译器直接支持，效率最高
`pthread_key_create`	动态TLS	更灵活但性能较低（需函数调用）
全局变量	共享数据	所有线程共用同一变量

使用注意事项

不可修饰类对象（C++）：
- __thread 在 C++ 中只能修饰 POD 类型（简单数据类型），不能修饰带构造函数的类

动态初始化限制：

// 错误！不能用非常量初始化
int global_init = 10;
__thread int bad_var = global_init;

兼容性问题：
- __thread 是 GCC/Clang 扩展，Windows 需用 __declspec(thread)
- 可移植代码建议使用 pthread_key_create

典型应用场景

场景	用途
错误码存储	每个线程维护独立的 `errno`
随机数种子	避免多线程共用随机数生成器
线程上下文	存储线程专属数据（如用户ID）

底层实现原理

编译器会为 __thread 变量生成：

线程局部存储段（TLS Section）：每个线程启动时分配独立空间
隐式线程ID关联：通过线程控制块（TCB）定位变量地址

访问 __thread 变量时，实际执行以下伪代码：

// 伪代码：获取__thread变量地址
void* get_tls_addr(__thread_var) {
    return TCB->tls_section + offset_of(__thread_var);
}

总结

关键点	说明
功能	为每个线程提供变量的独立副本
性能	比 `pthread_key_create` 更高效
限制	仅支持简单数据类型，初始化受限
适用场景	需要线程隔离数据的场景（如 `errno`）

__thread 是高性能线程局部存储的首选方案，但需注意其平台兼容性限制

相关推荐

Linux 线程控制

POSIX 线程库

使用 pthread 注意事项

pthread_create 函数：线程创建

函数原型

参数说明

返回值

使用示例

注意事项

常见错误

pthread_exit 函数：线程终止

函数原型

参数说明

关键特性

使用示例

与 return 的区别

注意事项

常见问题

Q1: 为什么不能返回局部变量？

Q2: 如何安全地返回数据？

Q3: 主线程调用 pthread_exit 会怎样？

总结

pthread_cancel 函数：线程取消

函数原型

参数说明

返回值

线程取消的工作原理

相关函数

使用示例

*注意事项

常见问题

Q1: 为什么线程没有立即终止？

Q2: 如何安全地终止线程？

Q3: 取消后如何回收资源？

总结

pthread_cleanup_push 和 pthread_cleanup_pop 函数：线程资源清理

函数原型

核心功能

触发清理的三种情况

使用示例

关键注意事项

典型应用场景

常见问题

Q1: 为什么 pthread_cleanup_pop 需要参数？

Q2: 清理函数可以嵌套吗？

Q3: 如果线程正常 return，如何确保资源释放？

总结

pthread_join 函数：线程等待与资源回收

为什么需要线程等待？

（1）资源回收

（2）获取返回值

（3）同步控制

函数原型

工作流程

使用示例

（1）基本用法（等待线程结束）

（2）忽略返回值

（3）错误处理

关键注意事项

（1）线程必须可连接（Joinable）

（2）返回值的内存管理

（3）禁止重复调用

（4）主线程退出问题

常见问题

Q1: 不调用 pthread_join 会怎样？

Q2: 如何避免阻塞等待？

总结

pthread_detach 函数：线程分离

为什么需要线程分离？

（1）默认问题

（2）分离线程的优势

函数原型

使用方式

关键特性

使用示例

注意事项

常见问题

Q1: 分离线程和守护线程的区别？

`pthread_create` 函数：线程创建

`pthread_exit` 函数：线程终止

与 `return` 的区别

Q3: 主线程调用 `pthread_exit` 会怎样？

`pthread_cancel` 函数：线程取消

`pthread_cleanup_push` 和 `pthread_cleanup_pop` 函数：线程资源清理

Q1: 为什么 `pthread_cleanup_pop` 需要参数？

Q3: 如果线程正常 `return`，如何确保资源释放？

`pthread_join` 函数：线程等待与资源回收

Q1: 不调用 `pthread_join` 会怎样？

`pthread_detach` 函数：线程分离

线程局部存储（TLS）技术：`__thread` 关键字详解

`__thread` 的基本用法