线程相关知识

线程是进程内的一条独立执行流，是操作系统调度 CPU 的最小单位，共享进程的地址空间与资源，有自己独立的栈、寄存器、程序计数器。

一、核心本质拆解

1.从属关系
进程是资源分配最小单位（内存、文件、句柄）；
线程是CPU 调度最小单位，寄生在进程里，一个进程至少有 1 个主线程。
2.资源共享 & 私有
共享：代码段、全局变量、堆内存、文件描述符、信号处理方式
私有：线程栈、寄存器上下文、PC 程序计数器、线程局部变量 TLS
3.轻量级的根本原因
创建 / 销毁线程不用重新分配虚拟地址空间，只配私有栈和 TCB（线程控制块），开销远小于进程；
切换线程不用切换页表、刷新 TLB，切换成本极低。

二、线程的状态

线程五大核心状态汇总表

注：基于 Linux/Java 通用线程模型，适配面试核心考点，区分核心特征与流转逻辑

面试核心总结

• 只有运行态占用CPU，就绪、阻塞态均不占用CPU资源

• 线程不会从阻塞态直接进入运行态，必须先回到就绪态，等待CPU调度

• 阻塞是主动放弃CPU，就绪是等待CPU分配，二者本质区别：是否具备立刻执行的条件

三、线程和进程区别

四、多线程相关函数

1.创建与终止函数

（1）pthread_create 创建线程

（2）pthread_exit 线程退出

示例代码

#include <stdio.h> #include <stdlib.h> #include <pthread.h> // 必须包含 pthread 头文件 #include <unistd.h> // 用于 sleep() // 1. 定义线程入口函数：必须符合 void* (*)(void*) 的签名 void *thread_func(void *arg) { // 把主线程传来的参数强转为 int 类型 int thread_num = *(int *)arg; free(arg); // 释放主线程动态分配的参数内存（避免内存泄漏） printf("子线程 %d 开始运行\n", thread_num); // 模拟耗时任务 sleep(2); // 2. 线程退出，并返回状态值（这里用线程号作为示例） pthread_exit((void *)(long)thread_num); } int main() { int thread_count = 3; pthread_t threads[thread_count]; // 存储线程ID的数组 for (int i = 0; i < thread_count; i++) { // 动态分配内存传递参数（避免栈变量被覆盖的经典坑） int *arg = malloc(sizeof(int)); *arg = i; // 3. 创建线程 int ret = pthread_create( &threads[i], // 输出：线程ID NULL, // 使用默认线程属性 thread_func, // 线程入口函数 arg // 传递给入口函数的参数 ); if (ret != 0) { perror("pthread_create 失败"); exit(EXIT_FAILURE); } } printf("主线程等待所有子线程结束...\n"); // 4. 等待所有子线程结束，并回收资源 for (int i = 0; i < thread_count; i++) { void *retval; pthread_join(threads[i], &retval); // 阻塞等待子线程退出 // 强转回 int，打印子线程的退出状态 printf("子线程 %d 已退出，返回值：%ld\n", i, (long)retval); } printf("所有子线程已结束，主线程退出\n"); return 0; }

2.线程标识函数

（1）pthread_self函数

pthread_self() 是无参数、无失败情况的函数，调用它只会返回当前线程的 ID。
它和 pthread_create 中获取的线程 ID 是同一种类型 pthread_t，但不能直接和操作系统的 LWP（轻量级进程 ID）划等号。
常用于线程内部打印日志、调试，或作为线程的唯一标识使用

（2）示例代码

#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> // 线程入口函数 void *thread_func(void *arg) { int thread_num = *(int *)arg; free(arg); // ✅ 关键：用 pthread_self() 获取当前线程的ID pthread_t tid = pthread_self(); printf("子线程 %d 运行，线程ID: %lu\n", thread_num, (unsigned long)tid); sleep(1); pthread_exit((void *)(long)thread_num); } int main() { int thread_count = 2; pthread_t threads[thread_count]; printf("主线程启动，主线程ID: %lu\n", (unsigned long)pthread_self()); for (int i = 0; i < thread_count; i++) { int *arg = malloc(sizeof(int)); *arg = i; int ret = pthread_create(&threads[i], NULL, thread_func, arg); if (ret != 0) { perror("pthread_create failed"); exit(EXIT_FAILURE); } } // 等待所有子线程结束 for (int i = 0; i < thread_count; i++) { void *retval; pthread_join(threads[i], &retval); printf("子线程 %d 已退出\n", (int)(long)retval); } printf("所有子线程结束，主线程退出\n"); return 0; }

1.pthread_t 类型
它是一个不透明类型，通常是无符号长整型，所以打印时需要强转为 unsigned long 类型。
2.pthread_self() vs gettid()
pthread_self() 返回的是用户态线程库中的线程 ID，仅在进程内唯一。
gettid() 返回的是内核 LWP ID，全局唯一，但不是标准库函数，需要系统调用。
3.典型用途
线程内部调试日志（打印当前线程 ID）
线程局部存储（TLS）中作为键使用
线程间互斥 / 同步时标识身份

3.线程回收函数

（1）pthread_join 线程回收

（2）pthread_attr_init 初始化线程属性

（3）pthread_attr_setdetachstate 设置分离状态

（4）pthread_attr_destroy 销毁线程属性

（5）结合态与分离态

（6）示例代码

#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> // 线程入口函数 void *thread_func(void *arg) { int id = *(int *)arg; free(arg); printf("线程 %d 开始运行，tid: %lu\n", id, (unsigned long)pthread_self()); sleep(1); // 模拟耗时任务 printf("线程 %d 运行结束\n", id); pthread_exit((void *)(long)id); } int main() { pthread_t tid_joinable, tid_detached; pthread_attr_t attr; // -------------------- 1. 创建结合态线程（默认） -------------------- int *arg1 = malloc(sizeof(int)); *arg1 = 1; pthread_create(&tid_joinable, NULL, thread_func, arg1); // -------------------- 2. 创建分离态线程（通过属性设置） -------------------- int *arg2 = malloc(sizeof(int)); *arg2 = 2; // 初始化线程属性 pthread_attr_init(&attr); // 设置为分离态 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); // 使用自定义属性创建线程 pthread_create(&tid_detached, &attr, thread_func, arg2); // 销毁属性对象（属性对象可以重复使用，这里用完直接销毁） pthread_attr_destroy(&attr); // -------------------- 3. 回收结合态线程 -------------------- void *retval; printf("主线程等待结合态线程1结束...\n"); pthread_join(tid_joinable, &retval); printf("结合态线程1已回收，退出状态：%ld\n", (long)retval); // 注意：分离态线程无法被join，也不需要手动回收 printf("主线程结束，分离态线程2将由系统自动回收资源\n"); sleep(2); // 等待分离态线程执行完毕，防止主线程提前退出 return 0; }

（7）核心注意事项

1.pthread_join 只能回收结合态线程
对分离态线程调用 pthread_join 会直接失败，返回 EINVAL 错误。
2.线程属性对象可复用
初始化后的 pthread_attr_t 可以多次用于创建线程，用完再销毁即可。
3.主线程退出会杀死所有子线程
即使是分离态线程，如果主线程提前 exit()，所有子线程都会被强制终止，所以主线程需要确保子线程执行完毕。
4.线程退出方式
pthread_exit()：仅结束当前线程，不影响其他线程
return：在线程函数中 return 等价于 pthread_exit()
exit()：结束整个进程，所有线程都会终止

4.线程控制函数

（1）pthread_detach 分离线程

与 pthread_attr_setdetachstate 的区别：
pthread_attr_setdetachstate：创建线程前，通过属性设置为分离态。
pthread_detach：创建线程后，将其转为分离态。

（2）pthread_cancel 取消线程

（3）pthread_setcancelstate 设置取消状态

（4）pthread_setcanceltype 设置取消类型

(5) 关键解析

取消点（Cancel Point）
当线程处于延时取消模式时，只有在调用特定系统函数（如 sleep()、read()、write()、pthread_cond_wait() 等）时，才会响应取消请求并退出。
取消线程的风险
直接取消线程可能导致资源泄漏（如未释放的锁、未关闭的文件句柄）。
建议配合清理函数 pthread_cleanup_push/pop 使用，确保线程退出前能释放资源。

（6）完整示例代码

#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> // 线程清理函数：线程被取消时自动调用 void cleanup(void *arg) { printf("线程清理：释放资源，参数=%p\n", arg); } void *thread_func(void *arg) { // 注册清理函数（栈式注册，push和pop必须成对出现） pthread_cleanup_push(cleanup, (void*)0x1234); printf("子线程开始运行，tid: %lu\n", (unsigned long)pthread_self()); // 设置取消类型为延时取消（默认） int oldtype; pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldtype); // 模拟耗时任务，sleep是取消点 for (int i = 0; i < 5; i++) { printf("子线程运行中...%d\n", i); sleep(1); } printf("子线程正常结束\n"); // 弹出清理函数（若线程正常结束，清理函数不会被执行） pthread_cleanup_pop(0); return NULL; } int main() { pthread_t tid; pthread_create(&tid, NULL, thread_func, NULL); sleep(2); // 让子线程运行一段时间 printf("主线程发送取消请求\n"); pthread_cancel(tid); // 发送取消请求 // 等待线程结束并回收资源 void *retval; pthread_join(tid, &retval); if (retval == PTHREAD_CANCELED) { printf("线程已被取消\n"); } else { printf("线程正常结束，返回值=%p\n", retval); } return 0; }

（7）核心注意事项

pthread_cancel 只是发送请求，不是强制终止。线程是否响应、何时响应，取决于其取消状态和类型。
分离态线程也可以被取消，但主线程无法通过 pthread_join 获取其退出状态。
尽量避免异步取消，它会导致线程在任意位置终止，极易造成资源泄漏和状态不一致。
清理函数 pthread_cleanup_push/pop 必须成对使用，且必须写在同一函数的同一层级中，否则会导致栈

5.线程的通信方式

传数据：共享变量
防竞争：互斥锁
等条件、排队干活：条件变量
限流计数：信号量
读多写少优化：读写锁
异步通知唤醒：线程信号 / 事件

五、总结

1、pthread 线程生命周期 全景表格

2、线程 生命周期流程图（文字版）

主线程 ↓ pthread_create ——→ 创建子线程（新建 → 就绪 → 运行） ↓ 子线程开始执行 ↓ 子线程运行中： - 可调用 pthread_self 获取自己ID - 可设置 setcancelstate / setcanceltype ↓ 子线程两种结束方式： 1. 正常结束 → return / pthread_exit 2. 被取消 → pthread_cancel（到达取消点退出） ↓ 线程结束后： ├── 若为 JOINABLE（默认）→ 必须 pthread_join 回收 └── 若为 DETACHED → 系统自动回收，无需 join

joinable 必须 join，否则资源泄漏
detached 不能 join，系统自动清理
cancel 只是发请求，不是立即杀死，默认延时取消

3、完整示例

#include <stdio.h> #include <pthread.h> #include <unistd.h> // 线程运行函数 void* func(void* arg) { int id = *(int*)arg; // 获取自身线程ID pthread_t tid = pthread_self(); printf("线程%d 运行，tid=%lu\n", id, (unsigned long)tid); // 设置允许取消（默认就是允许，演示用） pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); // 设置延时取消（默认，安全） pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL); sleep(3); // 取消点 printf("线程%d 正常结束\n", id); return NULL; } int main() { pthread_t tid; int num = 1; // 1. 创建线程 pthread_create(&tid, NULL, func, &num); sleep(1); // 2. 取消线程 pthread_cancel(tid); // 3. 等待回收（必须join，因为默认joinable） void* ret; pthread_join(tid, &ret); if (ret == PTHREAD_CANCELED) printf("线程已被取消\n"); return 0; }