线程安全的通行证：_REENTRANT与C语言的隐秘战场

高子歌

 关注

阅读 63

08-03 12:00

在计算机的世界里，有一种无形的战争每天都在上演。它没有硝烟，却关乎程序的生死存亡。当你打开电脑，运行一个程序，你以为它只是安静地执行指令，殊不知在它的内部，无数线程（轻量级执行单元）正像一群饥饿的蚂蚁，争抢着同一块名为“资源”的面包。如果它们不遵守规则，面包会被撕得粉碎，程序也会轰然崩溃。而在这场混乱的战争中，有一个低调却至关重要的角色——_REENTRANT。它就像一张通行证，决定着哪些函数能在这片混乱中安然无恙。

一、混乱的根源：当多个线程同时敲门

想象一个场景：你正在图书馆自习，桌上摊着一本珍贵的参考书。突然，另一个人也冲过来想看这本书。如果你们俩同时伸手去翻页，结果会怎样？书页可能被撕坏，或者你们各自看到的是混乱的片段。这就是多线程程序面临的“资源竞争”问题。

在C语言中，函数就像图书馆里的书，而全局变量、静态变量、文件句柄等就是那本珍贵的参考书。当多个线程同时调用同一个函数，而这个函数又操作了这些共享资源时，灾难就发生了。比如：

#include <stdio.h>

int counter = 0; // 全局变量，所有线程共享

void increment() {
    counter++; // 看似简单的一行，实则暗藏杀机
}

counter++ 这行代码在机器层面至少包含三步：读取counter的值、将其加1、把新值写回counter。如果线程A执行到第二步时，线程B突然插队执行了整个操作，那么线程A写回的值就会覆盖掉线程B的结果，最终计数器只增加了1，而不是2。这就是典型的“竞态条件”（Race Condition），多线程编程中最阴险的敌人之一。

二、可重入函数：混乱中的秩序守护者

为了应对这种混乱，C语言引入了“可重入函数”（Reentrant Function）的概念。可重入函数就像一个训练有素的图书管理员，无论多少读者同时来借书，他都能有条不紊地处理，确保每本书被正确登记、归还。

一个函数要成为可重入函数，必须满足几个铁律：

  1. 不依赖静态或全局数据：所有数据都来自调用者（通过参数传递）或函数自身的局部变量（栈上分配）。
  2. 不调用不可重入函数：比如malloc、free、printf（在某些实现中）等。
  3. 不返回静态或全局数据的指针：避免让调用者获得共享资源的“钥匙”。
  4. 小心处理信号：信号（Signal）是异步事件，可能在函数执行中途打断它。可重入函数需要确保即使被信号打断，也不会破坏共享状态。

可重入函数是线程安全的基石（线程安全指函数在多线程环境下被调用时，仍能正确处理共享资源，不会导致数据损坏或程序异常）。但问题是，C标准库中很多函数天生就不是可重入的，比如strtok，它内部用一个静态指针来记住上次解析的位置。如果多个线程同时用strtok解析不同的字符串，这个静态指针就会被搞得一团糟。

三、_REENTRANT：编译器的隐秘指令

这时，_REENTRANT 就登场了。它是一个预处理器宏（Preprocessor Macro），一个在编译代码之前由预处理器处理的简单文本替换指令。它本身不执行任何操作，但它像一个开关，告诉编译器和C标准库：“嘿，我要构建一个多线程安全的程序！请帮我启用那些线程安全的替代方案！”

当你定义了_REENTRANT（通常通过编译选项-D_REENTRANT），会发生一系列连锁反应：

  1. 暴露可重入版本：标准库中那些不可重入的函数（如strtok），会同时提供可重入的替代版本（如strtok_r）。_REENTRANT的存在会让这些可重入版本的头文件声明变得可见。
  2. 启用线程安全实现：标准库内部的一些实现细节会改变。例如，errno（记录系统调用错误码的全局变量）不再是全局的，而是变成了每个线程私有的副本（线程局部存储，Thread-Local Storage）。这样，一个线程设置errno不会影响另一个线程。
  3. 影响函数行为：某些函数的行为可能会改变。比如gethostbyname（通过主机名获取IP地址）在定义_REENTRANT后，可能使用线程安全的方式返回结果，而不是依赖静态缓冲区。

简单来说，_REENTRANT 是一个编译时标志，它引导编译器和标准库为多线程环境做好准备，提供线程安全的“武器库”。

四、实战演练：用_REENTRANT驯服strtok

让我们用经典的strtok来感受一下_REENTRANT的力量。strtok用于分割字符串，但它内部用一个静态指针保存位置，天生就是线程不安全的。

不安全的版本（未定义_REENTRANT）

#include <stdio.h>
#include <string.h>

// 假设这个函数会被多个线程调用
void parse_string(char *str) {
    char *token;
    // 第一次调用strtok，传入字符串
    token = strtok(str, " ,"); // 使用空格或逗号分割
    while (token != NULL) {
        printf("Thread %lu: Token: %s\n", (unsigned long)pthread_self(), token);
        // 后续调用传入NULL，继续分割原字符串
        token = strtok(NULL, " ,");
    }
}

// 线程函数
void *thread_func(void *arg) {
    char my_string[] = "Hello,world,from,thread";
    parse_string(my_string);
    return NULL;
}

int main() {
    pthread_t tid1, tid2;

    // 创建两个线程
    pthread_create(&tid1, NULL, thread_func, NULL);
    pthread_create(&tid2, NULL, thread_func, NULL);

    // 等待线程结束
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    return 0;
}

编译并运行（注意：未定义_REENTRANT）：

gcc -o unsafe_strtok unsafe_strtok.c -lpthread
./unsafe_strtok

输出可能极其混乱（实际结果取决于线程调度）：

Thread 12345678: Token: Hello
Thread 87654321: Token: Hello
Thread 12345678: Token: world
Thread 87654321: Token: world
... (可能崩溃或输出错乱)

两个线程的strtok调用互相干扰，因为它们共享同一个静态指针。一个线程分割到一半，另一个线程可能就把它指向的位置改了。

安全的版本（定义_REENTRANT）

现在，我们定义_REENTRANT，并使用其提供的可重入替代品strtok_r。

#define _REENTRANT  // 关键！定义宏
#include <stdio.h>
#include <string.h>
#include <pthread.h>

// 使用可重入版本strtok_r
void parse_string_r(char *str) {
    char *token;
    char *saveptr; // strtok_r需要的额外指针，用于保存状态
    // 第一次调用，传入字符串和saveptr的地址
    token = strtok_r(str, " ,", &saveptr);
    while (token != NULL) {
        printf("Thread %lu: Token: %s\n", (unsigned long)pthread_self(), token);
        // 后续调用传入NULL和saveptr的地址
        token = strtok_r(NULL, " ,", &saveptr);
    }
}

// 线程函数
void *thread_func_r(void *arg) {
    char my_string[] = "Hello,world,from,thread";
    parse_string_r(my_string);
    return NULL;
}

int main() {
    pthread_t tid1, tid2;

    pthread_create(&tid1, NULL, thread_func_r, NULL);
    pthread_create(&tid2, NULL, thread_func_r, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    return 0;
}

编译并运行（定义了_REENTRANT）：

gcc -D_REENTRANT -o safe_strtok safe_strtok.c -lpthread
./safe_strtok

输出会清晰有序：

Thread 12345678: Token: Hello
Thread 12345678: Token: world
Thread 12345678: Token: from
Thread 12345678: Token: thread
Thread 87654321: Token: Hello
Thread 87654321: Token: world
Thread 87654321: Token: from
Thread 87654321: Token: thread

每个线程都独立、完整地分割了自己的字符串，互不干扰。strtok_r通过要求调用者提供一个saveptr指针（通常在栈上分配，线程私有）来保存状态，彻底避免了静态变量带来的共享问题。

五、_REENTRANT的边界：它不是万能药

_REENTRANT 是强大的，但并非无所不能。它主要解决的是标准库函数本身的线程安全性问题。它做了两件事：

  1. 提供可重入替代品：如strtok_r替代strtok。
  2. 让库内部状态线程私有：如errno。

但它不能：

  • 自动让你的代码线程安全：如果你自己写的函数使用了全局变量或静态变量，_REENTRANT 对此无能为力。你需要自己动手加锁（如互斥锁 Mutex）或改用线程局部存储。
  • 解决所有竞态条件：即使你用了_REENTRANT和可重入函数，如果你的多个线程操作的是同一个共享数据结构（比如一个全局链表），你仍然需要用锁（如pthread_mutex_t）来保护临界区（指同一时间只允许一个线程访问的代码区域）。
  • 保证所有平台行为一致：虽然_REENTRANT是POSIX标准的一部分，但不同操作系统或C库实现（如glibc, musl）在细节上可能有差异。你需要查阅具体平台的文档。

六、更深层的战场：线程局部存储（TLS）

_REENTRANT 让errno变成线程私有，这背后依赖的技术是线程局部存储（Thread-Local Storage, TLS）。TLS是一种机制，让每个线程拥有自己独立的数据副本，即使变量名是“全局”的。

在C中，可以使用__thread关键字（GCC/Clang扩展）或_Thread_local（C11标准）来声明线程局部变量：

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

// 声明一个线程局部变量
__thread int thread_specific_counter = 0;

void *thread_func(void *arg) {
    // 每个线程操作的是自己的thread_specific_counter副本
    thread_specific_counter++;
    printf("Thread %lu: My counter = %d\n", (unsigned long)pthread_self(), thread_specific_counter);
    return NULL;
}

int main() {
    pthread_t tid1, tid2;

    pthread_create(&tid1, NULL, thread_func, NULL);
    pthread_create(&tid2, NULL, thread_func, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    // 主线程也有自己的副本
    thread_specific_counter = 100;
    printf("Main thread: My counter = %d\n", thread_specific_counter);

    return 0;
}

编译运行：

gcc -o tls_example tls_example.c -lpthread
./tls_example

输出类似：

Thread 12345678: My counter = 1
Thread 87654321: My counter = 1
Main thread: My counter = 100

每个线程（包括主线程）的thread_specific_counter都是独立的，互不影响。TLS是实现线程安全私有数据的利器，_REENTRANT正是利用它解决了errno等问题。

七、信号处理：异步的惊雷

多线程程序还要提防一种特殊的“不速之客”——信号（Signal）。信号是软件中断，可以在任何时刻异步地打断程序的执行。如果信号处理函数（Signal Handler）在执行时，恰好打断了某个正在操作共享资源的函数，而该函数又不是可重入的，后果不堪设想。

例如，假设信号处理函数调用了malloc，而主线程在信号到来时也正在调用malloc。如果malloc内部使用了全局锁或状态，这种异步调用就可能导致锁死或内存池损坏。

因此，信号处理函数必须是可重入的！ 它只能调用异步信号安全（Async-Signal-Safe）的函数。POSIX标准明确列出了哪些函数是异步信号安全的（如write, _exit, sigprocmask等），printf, malloc, free等都不在其中。

_REENTRANT 在这里的作用是间接的：它鼓励使用可重入函数，而可重入函数通常是（但不总是）异步信号安全的。但最终，确保信号处理函数的安全，是程序员的责任，需要极其谨慎地选择其中调用的函数。

八、实践指南：在代码中运用_REENTRANT

对于大学生，尤其是刚接触多线程的大一新生，如何正确使用_REENTRANT？这里有一个简明的指南：

  1. 编译时定义它：只要你的程序可能涉及多线程（使用了pthread），就在编译时加上-D_REENTRANT选项。养成习惯，有备无患。

gcc -D_REENTRANT -o my_program my_program.c -lpthread

  1. 优先使用可重入函数：当标准库提供_r后缀的可重入版本时（如strtok_r, asctime_r, gethostbyname_r），优先使用它们。查阅手册页（man strtok）看是否有_r版本。
  2. 警惕共享状态：_REENTRANT不能保护你自己的全局变量和静态变量。如果多个线程需要访问它们：
  • 加锁：使用pthread_mutex_t互斥锁保护临界区。
  • 改用TLS：如果数据天然属于线程，使用__thread或_Thread_local。
  • 避免共享：尽量通过参数传递数据，减少共享。
  1. 小心信号处理：保持信号处理函数极其简单，只调用异步信号安全函数。避免在信号处理函数中做复杂操作。
  2. 理解平台差异：虽然_REENTRANT是POSIX标准，但具体实现细节（如哪些函数有_r版本，TLS支持）可能不同。关注你使用的操作系统（Linux, macOS等）和C库（glibc等）的文档。

九、结语：秩序源于规则

在计算机科学的世界里，混乱是常态，秩序是追求。多线程编程就像在刀尖上跳舞，既带来强大的并发能力，也埋藏着无数陷阱。_REENTRANT，这个看似不起眼的宏，正是秩序的守护者之一。它不直接解决所有问题，但它为我们铺平了道路，提供了工具，指明了方向。

它告诉我们，线程安全不是凭空而来的魔法，而是建立在清晰的规则和谨慎的实践之上。理解_REENTRANT，就是理解多线程环境下资源管理的核心逻辑——隔离、同步、最小化共享。当你下次在代码中加入-D_REENTRANT，或者选择strtok_r而非strtok时，你不仅仅是在写一行代码，你是在为你的程序颁发一张在混乱世界中安全通行的许可证。

记住，在数字的丛林里，规则不是束缚，而是生存的智慧。_REENTRANT，就是这智慧中低调而坚实的一块基石。

相关推荐

pycharm通行证更新问题

十里一走马 39 0 0

javaSE运算符总集篇(java世界的通行证)

三分梦_0bc3 27 0 0

Socks5代理：数字时代的通行证

左小米z 32 0 0

【OAuth2】：赋予用户控制权的安全通行证--原理篇

茗越 28 0 0

ONES CTO 冯斌 | 敏捷思想是不确定时代的通行证

笙烛 82 0 0

BAT通行证 600多道各大公司必考java面试题合集+答案

yeamy 67 0 0

C语言 线程的回收与子线程返回值的接收

素锦时年_1b00 26 0 0

Java中的线程安全与线程同步

westfallon 20 0 0

Python多线程与多进程：异同与实战场景解析

犹大之窗 18 0 0

2022年安全员-C证考试及安全员-C证报名考试

Silence潇湘夜雨 60 0 0

精彩评论（0）

0 0 举报