并发竞态条件实战:线程安全 Bug 分析

问题背景

某即时通讯 (Instant Messaging, IM) 服务的资料卡片接口 GetProfileList 按安全要求,需将用户注册时间字段 (tag 20026) 做归一化处理后再下发:将注册时间归一到"注册年份的 1 月 1 日",同时保留原有的时分秒信息.

例如,某用户注册于 2023-06-15 14:30:00,归一化后下发的值应对应 2023-01-01 14:30:00. 这一处理的目的是模糊化精确注册日期,降低用户隐私暴露风险.

负责这一转换的函数名为 modifyAndPrintTime,其核心逻辑大致如下:

// 伪代码:将时间戳归一化到当年 1 月 1 日
std::string modifyAndPrintTime(uint32_t timestamp) {
    time_t t = static_cast<time_t>(timestamp);
    struct tm* tm_ptr = std::localtime(&t);    // ⚠️ 问题所在
    tm_ptr->tm_mon = 0;   // 1 月
    tm_ptr->tm_mday = 1;  // 1 日
    time_t normalized = std::mktime(tm_ptr);   // ⚠️ 同样有问题
    return formatTime(normalized);
}

这个函数于 2025 年 1 月上线,运行约 1.5 年后才被发现存在线程安全问题.

根因分析

std::localtime 的非线程安全性

std::localtime 返回一个指向静态内部缓冲区 (static internal buffer) 的指针. C 标准明确规定:

The return value is a pointer to an internal object whose validity or value may be altered by any subsequent call to gmtime or localtime.

这意味着所有线程共享同一块内存. 在多线程环境下,当线程 A 调用 localtime 后还没来得及读取结果,线程 B 的 localtime 调用就可能覆写这块缓冲区的内容.

sequenceDiagram
    participant T1 as 线程 A(用户 X)
    participant Buf as 静态缓冲区
    participant T2 as 线程 B(用户 Y)

    T1->>Buf: localtime(timestamp_X) 写入 X 的时间
    T2-->>Buf: localtime(timestamp_Y) 写入 Y 的时间(覆写!)
    T1->>Buf: 读取 tm_mon, tm_mday... 读到的是 Y 的值!
    Note over T1,T2: 线程 A 最终返回了用户 Y 的归一化时间

两个竞态窗口

在同一次 modifyAndPrintTime 调用中,实际存在两个竞态窗口:

1. 读竞态:localtime 返回后,tm_ptr 指向的缓冲区可能被其他线程的 localtime 调用覆盖.
2. 写竞态:修改 tm_ptr->tm_mon 和 tm_ptr->tm_mday 时,改的也是共享缓冲区;如果此时另一线程恰好调用 localtime,会把修改后的值当作"原始解析结果"返回给那个线程.

std::mktime 同样使用静态缓冲区,存在相同的线程安全问题--它可能把其他线程刚修改过的 struct tm 当作自己的输出.

症状表现

竞态条件导致的错误具有非确定性和偶发性两个核心特征,使得问题极难被发现和复现.

症状一:同一用户多次返回不同注册年份

同一用户连续多次调用 GetProfileList,返回的注册时间 (20026) 偶尔出现不同的年份值. 在压测环境下,对同一用户反复请求,部分返回中注册年份从 2023 跳变为 2020 或 2025,呈现完全不可预测的跳动模式.

症状二:跨用户数据泄漏

更隐蔽也更严重的是,接口偶发返回另一个用户的注册时间. 线上曾复现过一个典型脏值 1167614079 (Unix 时间戳),该值不属于当前请求用户,而是属于同一批次中另一个用户的注册时间. 在极端情况下,甚至出现"整段泄漏"--整个注册时间字段完全替换为其他用户的值.

跨用户泄漏的本质:线程 A 的 localtime 结果被线程 B 覆盖后,线程 A 读取到了线程 B 的时间结构体,后续每一步操作(置为 1 月 1 日 → mktime → 格式化)都基于错误的值,最终产出了完全属于另一个用户的归一化时间.

影响评估

触发概率

压测数据提供了一个量化的触发概率参考:

• 高并发场景(单请求携带约 150 个用户 ID 批量查询):约 0.4% 的响应中出现错误年份.
• 正常流量(并发度远低于压测):触发概率估计在千分之几以下级别,偶发,非稳定复现.

影响范围

综合评定:低危展示类问题--不影响功能正确性和服务可用性,但存在隐私合规风险,需要修复.

修复方案

修复非常直接:将 modifyAndPrintTime 中对 std::localtime 和 std::mktime 的调用替换为对应的线程安全版本.

方案对比

推荐实现

std::string modifyAndPrintTime(uint32_t timestamp) {
    time_t t = static_cast<time_t>(timestamp);
    struct tm tm_buf;                              // 线程局部缓冲区
    struct tm* tm_ptr = localtime_r(&t, &tm_buf);  // 写入调用方提供的缓冲区
    if (tm_ptr == nullptr) {
        return "";
    }
    tm_ptr->tm_mon = 0;   // 1 月
    tm_ptr->tm_mday = 1;  // 1 日
    time_t normalized = std::mktime(tm_ptr);
    return formatTime(normalized);
}

核心变化只有两处:

1. 将 struct tm* 改为栈上 struct tm:每个线程在自己的栈帧中拥有独立缓冲区.
2. 用 localtime_r 替代 localtime:将结果写入调用方提供的缓冲区而非全局静态缓冲区.

测试验证

修复后的验证策略聚焦于黑盒多次验证,不依赖代码内部实现:

稳定性验证

同一用户连续多次调用 GetProfileList 接口,注册时间 (20026) 字段取值应唯一且恒定. 修复前偶发出现多个不同年份的返回值,修复后任何多次请求之间不应有差异.

归一化正确性验证

返回值的时间应为"注册年份的 1 月 1 日 + 原始时分秒",且不得出现其他用户的注册时间. 验证方法:

• 从数据库直接查询用户真实注册时间,手工计算期望的归一化值
• 与接口返回值逐字段比对
• 对批量请求中的每个用户 ID 做交叉校验,确保不存在跨用户串值

经验教训

为什么这个 bug 能存活 1.5 年?

1. 低触发概率:正常流量下千分之几以下的偶发错误,几乎不可能被人工发现.
2. 非确定性:问题不会稳定复现--同一次请求有时对有时错,自动化测试也很难抓到.
3. 影响面窄:只是年份偶尔串成别的值,不影响核心逻辑,不崩溃,缺乏告警信号.
4. 认知盲区:localtime 是 C 标准库中最常用的函数之一,很多人默认它是"安全的"--直到第一次遇到并发 bug.

如何从流程上避免?

• Code Review 检查清单:审查涉及时间处理的代码时,localtime / gmtime / asctime / ctime 应作为高危关键词被标记.
• 静态分析工具:Clang-Tidy 的 concurrency-mt-unsafe 规则可以自动检测非线程安全的 C 标准库调用.
• 线程安全测试:对涉及共享状态的函数,应在压测中引入"同一请求重复多次 + 批量高并发"的场景来放大竞态窗口.
• 编译器警告:GCC 和 Clang 在较新版本中会对 localtime 等函数产生 deprecated 警告(当定义了 _POSIX_C_SOURCE 等宏时).

延伸:C 标准库中常见的非线程安全函数

#include <thread>
#include <vector>
#include <atomic>
#include <ctime>
#include <cstdio>

int main() {
    const int N_THREADS = 10;
    const int N_ITERS = 1000;
    std::atomic<int> errors{0};
    std::vector<std::thread> threads;

    for (int i = 0; i < N_THREADS; ++i) {
        threads.emplace_back([&] {
            for (int j = 0; j < N_ITERS; ++j) {
                time_t t = 1000000000 + j * 100000;
                struct tm* tm_ptr = std::localtime(&t);
                int year = tm_ptr->tm_year + 1900;
                time_t check_t = t;
                struct tm* check_ptr = std::localtime(&check_t);
                if (check_ptr->tm_year + 1900 != year) {
                    ++errors;
                }
            }
        });
    }

    for (auto& t : threads) t.join();
    printf("Total errors detected: %d\n", errors.load());
}