静态成员函数与线程安全：多线程日志类无锁为何未出异常？

我有一个所有方法均为静态的辅助日志类，包含私有静态方法，会被多线程调用。我无法理解为何该类的方法在无锁情况下能安全运行。

相关代码如下：

//Helper.cpp
std::recursive_mutex Logger::logMutex_;

void Logger::write(const std::string &logFilePath, const std::string &formattedLog)
{
    std::lock_guard<std::mutex> guard(logMutex_);
    std::ofstream logFile(logFilePath.c_str(), std::ios::out | std::ios::app);

    if (logFile.is_open())
    {
        logFile << formattedLog;
        logFile.close();
    }
}

void Logger::error(const string &appId, const std::string &fmt, ...)
{
    auto logFile = validateLogFile(appId); //验证对应app ID的日志文件是否存在的私有静态方法
    if (!logFile.empty())
    {
        //格式化日志
        write(logFile, log);
    }
}

//Helper.h
class Logger
{
    public:
        static void error(const std::string &Id, const std::string &fmt, ...);
    private:
        static void write(const std::string &fileName, const std::string &formattedLog);
        static std::recursive_mutex logMutex_;
};

我理解静态方法中的局部变量是线程私有的，每次调用都会创建栈并初始化变量。但Logger::write方法会打开文件并写入，多线程通过Logger::error调用write时，即使去掉锁，我认为应该出现数据竞争或崩溃——因为多线程尝试打开同一文件，即使内核允许多次打开，写入的数据也应存在问题。但我测试100个线程时，无论有无锁，都未崩溃且数据写入正常，无法理解原因。

测试代码如下：

TEST_F(GivenALogger, WhenLoggerMethodsAreCalledFromMultipleThreads_AllTheLogsMustBeLogged)
{
    std::vector<std::thread> threads;
    int num_threads = 100;

    int i = 0;

    for (; i < num_threads / 2; i++)
    {
        threads.push_back(std::thread(&Logger::error, validId, "Trial %d", i));
    }

    for (; i < num_threads; i++)
    {
        threads.push_back(std::thread(&Logger::debug, validId, "Trial %d", i));
    }

    std::for_each(threads.begin(), threads.end(), [](std::thread &t) { t.join(); });

    auto actualLog = getActualLog(); // 返回日志行的vector
    EXPECT_EQ(num_threads, actualLog.size());
}

另外，我该如何正确、安全地访问文件？

为什么无锁测试没出现问题？ #

你没观察到问题不代表不存在，这是典型的竞态条件偶发性导致的：

• 测试用例中每个线程写入的日志内容极短（仅"Trial X"），内核文件系统缓存和写入调度可能刚好把这些小写入操作做了原子化处理，没出现明显的内容错乱。
• 100个线程的并发量不算极高，加上每个线程的日志操作耗时很短，线程间写入冲突的概率被降低，刚好没触发可见错误。
• 不同操作系统的文件系统对多线程写入的处理逻辑有差异，比如部分系统在追加模式（ios::app）下会自动保证小数据量写入的原子性，但这不是C++标准行为，绝对不能依赖。

本质上，无锁的多线程写入同一文件是完全不安全的，一旦写入内容变长、并发量提高，必然会出现日志内容重叠、错乱，甚至极端情况下的文件损坏。

正确、安全的文件访问方式 #

针对多线程日志场景，推荐以下几种可靠方案：

1. 优化全局互斥锁方案 #

你当前代码已经用到了互斥锁，可以做两点优化提升性能和可靠性：

• 将std::recursive_mutex替换为普通std::mutex，因为你的代码不存在递归调用write的场景，递归锁的性能比普通锁差。
• 避免每次写入都打开/关闭文件，改用全局单例文件流：在程序启动时初始化打开日志文件，持有到程序结束，每次写入直接操作该流，配合锁保证线程安全，同时减少IO开销。

示例优化后的核心逻辑：

// Helper.cpp
std::mutex Logger::logMutex_;
std::ofstream Logger::logFile_; // 新增静态全局文件流

// 初始化函数，程序启动时调用
void Logger::init(const std::string& logFilePath) {
    std::lock_guard<std::mutex> guard(logMutex_);
    logFile_.open(logFilePath, std::ios::out | std::ios::app);
}

void Logger::write(const std::string &formattedLog) {
    std::lock_guard<std::mutex> guard(logMutex_);
    if (logFile_.is_open()) {
        logFile_ << formattedLog << std::flush; // 手动刷新确保内容写入磁盘
    }
}

2. 线程本地缓冲区+批量写入 #

给每个线程分配独立的日志缓冲区，当缓冲区满或线程结束时，持有全局锁将缓冲区内容一次性写入文件。这种方式能大幅减少锁的竞争频率，提升高并发场景下的性能。

3. 异步日志队列 #

创建一个独立的日志处理线程，业务线程只需要把日志消息发送到线程安全的队列中，由日志线程统一负责文件写入。这种方式完全避免了业务线程之间的锁竞争，是高并发场景下的最优解之一。

内容的提问来源于stack exchange，提问作者Muttal Kadavul