不可重入函数Non-Reentrant 可重入函数Reentrant-程序员充电站

用最通俗的生活例子理解：

可重入函数：像自动售货机 —— 你投币买水到一半，有人打断你去买零食，回来你继续投币，售货机仍能正确给你水（逻辑独立、不依赖 “半完成” 的状态）；
不可重入函数：像手工记账本 —— 你记到一半（写了 “收入 100” 但没写 “元”），有人打断你去记另一笔账，回来你忘了之前写到哪，账本就乱了（依赖全局状态、操作不原子）。

核心定义

函数类型核心定义通俗理解
可重入函数函数执行过程中被异步打断（如信号、中断、多线程调度），再次调用（重入）后，原流程和新流程都能正确执行，结果不受影响多个人同时用、中途被打断再用，都不会乱，逻辑完全 “自给自足”
不可重入函数函数执行过程中被异步打断后重入，会导致数据错乱、逻辑异常、结果错误只能 “一次性干完”，中途被打断就乱套，依赖全局状态 / 共享资源
关键前提：“重入” 的核心是异步打断 + 再次调用—— 比如信号处理函数打断主程序的malloc，又在信号处理函数里调用malloc，就是典型的 “重入不可重入函数”，必然出问题。

函数类型	核心定义	通俗理解
可重入函数	函数执行过程中被异步打断（如信号、中断、多线程调度），再次调用（重入）后，原流程和新流程都能正确执行，结果不受影响	多个人同时用、中途被打断再用，都不会乱，逻辑完全 “自给自足”
不可重入函数	函数执行过程中被异步打断后重入，会导致数据错乱、逻辑异常、结果错误	只能 “一次性干完”，中途被打断就乱套，依赖全局状态 / 共享资源

本质区别：为什么可重入函数 “不乱”？

可重入与不可重入的核心差异，在于是否依赖 “非私有资源” 和 “非原子操作”，用表格清晰对比：
对比维度可重入函数不可重入函数
依赖全局 / 静态变量 ❌ 完全不用（仅用参数 / 局部变量） ✅ 依赖（比如strtok用静态变量存分割位置）
操作共享资源（文件 / 内存） ❌ 仅操作函数内私有资源 ✅ 操作全局共享资源（比如printf用全局输出缓冲区）
调用其他不可重入函数 ❌ 只调用可重入函数 ✅ 调用malloc/printf等不可重入函数
非原子操作 ❌ 仅用原子操作（一步完成） ✅ 有分步操作（比如 “读全局变量→修改→写回”）
内存分配 / 释放 ❌ 不调用malloc/free（改内存池） ✅ 调用malloc/free
不可重入函数的 “坑”：具体怎么乱的？
举个经典例子 ——strtok（字符串分割函数，不可重入）：
// 不可重入的根源：strtok用静态变量保存“上次分割的位置” char *strtok(char *str, const char *delim); // 主程序执行： char str[] = "a,b,c,d"; strtok(str, ","); // 第一次调用，静态变量存“b,c,d”的起始地址 // 此时信号触发，信号处理函数里也调用strtok： strtok("x,y,z", ","); // 静态变量被覆盖为“y,z”的起始地址 // 信号处理完，主程序继续调用strtok： strtok(NULL, ","); // 本应取“b”，但静态变量被改，实际取到“y”，结果完全错了
而可重入版本strtok_r（r=reentrant）就解决了这个问题 —— 把 “分割位置” 从静态变量改成参数传入（私有资源），就算重入也不会乱：
// 可重入版本：用saveptr（局部变量）保存分割位置，不依赖全局 char *strtok_r(char *str, const char *delim, char **saveptr);

对比维度	可重入函数	不可重入函数
依赖全局 / 静态变量	❌ 完全不用（仅用参数 / 局部变量）	✅ 依赖（比如`strtok`用静态变量存分割位置）
操作共享资源（文件 / 内存）	❌ 仅操作函数内私有资源	✅ 操作全局共享资源（比如`printf`用全局输出缓冲区）
调用其他不可重入函数	❌ 只调用可重入函数	✅ 调用`malloc`/`printf`等不可重入函数
非原子操作	❌ 仅用原子操作（一步完成）	✅ 有分步操作（比如 “读全局变量→修改→写回”）
内存分配 / 释放	❌ 不调用`malloc`/`free`（改内存池）	✅ 调用`malloc`/`free`

常见的可重入 / 不可重入函数举例

1. 可重入函数（放心用，尤其是信号处理 / 多线程）
这些函数仅依赖参数和局部变量，无全局状态，操作原子：
内存操作：memcpy、memset、strcpy、strcmp（仅操作传入的参数）；
系统调用：write、read、_exit、close（内核级原子操作，不依赖用户态全局资源）；
基础运算：abs、sqrt（仅处理参数，无副作用）。
2. 不可重入函数（绝对不能在信号处理函数里用！）
这些函数依赖全局 / 静态资源，或有分步操作：
标准 IO：printf、fprintf、puts（用全局输出缓冲区，分步写入）；
内存管理：malloc、free、calloc（操作全局内存池，分步修改链表）；
定时器：sleep、alarm（修改全局定时器状态）；
字符串处理：strtok（静态变量）、asctime（静态缓冲区）；
其他：rand（静态随机数种子）、getenv（全局环境变量表）。

关键应用场景：为什么你必须关心？

这部分和“信号捕获” 强相关 ——信号处理函数必须用可重入函数，否则必出问题！
场景 1：信号处理打断不可重入函数
主程序正在执行malloc（修改全局内存池链表）：
主程序：malloc → 拆链表节点（只拆了一半） ↓ 信号触发（比如SIGINT） 信号处理函数：又调用malloc → 继续改同一个内存池链表 ↓ 信号处理完，主程序继续 主程序：malloc的链表已经乱了 → 内存泄漏/程序崩溃
场景 2：多线程调用不可重入函数
多线程同时调用printf：
线程1：printf("hello") → 写了“he”到全局缓冲区，被调度走 线程2：printf("world") → 覆盖缓冲区为“world”，输出 线程1：继续执行 → 缓冲区剩下的“llo”被输出 最终结果：worldllo（完全错乱）
核心原因：信号处理是 “异步打断”，多线程是 “并发执行”，二者都会触发函数的 “重入”—— 不可重入函数扛不住这种场景，可重入函数则完全没问题。

如何编写可重入函数？

只要遵守以下规则，就能写出安全的可重入函数：
绝不使用全局 / 静态变量：所有数据都通过参数传入（传值，而非传指针共享），或用函数内局部变量（栈上分配，每个调用独立）；
绝不调用不可重入函数：比如信号处理函数里，不能用printf/malloc/sleep，改用write（可重入）输出、_exit退出；
绝不操作共享资源：不写全局文件、不修改全局配置，仅操作函数内创建的私有资源；
只用原子操作：避免 “读 - 改 - 写” 分步操作（比如count++是三步：读 count→+1→写回，非原子），改用原子指令（如__sync_fetch_and_add）；
不依赖函数执行顺序：函数执行结果仅由输入参数决定，不受 “是否被打断” 影响（纯函数思想）。
正面例子（可重入函数）：
// 计算两数之和，仅用参数和局部变量，无全局依赖 int add(int a, int b) { int temp = a + b; // 局部变量，栈上分配，每个调用独立 return temp; } // 信号处理函数里的可重入输出（用write替代printf） void sig_handler(int sig) { char msg[] = "signal caught\n"; write(1, msg, sizeof(msg)-1); // write是可重入的系统调用 _exit(0); // _exit是可重入的退出函数（exit不可重入） }
反面例子（不可重入函数）：
int count = 0; // 全局变量 // 不可重入：依赖全局变量，count++是非原子操作 int increment() { count++; // 读count→+1→写回，中途被打断会乱 return count; }

核心总结

核心判断：可重入函数 =“自给自足”（仅用参数 / 局部变量），不可重入函数 =“依赖外部状态”（全局 / 静态 / 共享资源）；
关键风险：不可重入函数被异步打断（信号）/ 并发调用（多线程）会导致数据错乱，可重入函数则安全；
实战要求：信号处理函数、多线程核心逻辑必须用可重入函数，禁用printf/malloc等不可重入函数；
编写规则：不碰全局、不调不可重入函数、只用原子操作、结果仅由参数决定。
简单说：可重入函数是 “不怕打断的函数”，不可重入函数是 “一打断就乱的函数”—— 在异步 / 并发场景下，选可重入函数是唯一安全的选择。