C++20日志类未显式调用flush丢失日志：原因及是否属预期行为？

我在Windows平台上实现了一个基于C++20的简单日志类，用于逐行将数据写入文件。为保证线程安全，我使用静态std::mutex来序列化写入操作。

但我遇到一个问题：如果在持有锁时，每次写入后不显式调用flush，输出文件中会丢失部分日志行；而调用flush后，所有行都能正确写入文件。

以下是简化后的代码：

class Logger {
public:
    void Log(const std::string& message) {
        std::lock_guard lock(mtx_);
        log_file_ << std::format("{}\n", message);
        // log_file.flush(); // Uncommenting this works fine
    }

private:
    static std::mutex mtx_;
    std::ofstream log_file_{ "log.txt", std::ios::app };
};

std::mutex Logger::mtx_;

int main()
{
    std::vector<std::future<void>> futures;

    // Launch the function asynchronously
    for (int i = 0; i < 25; ++i) {
        futures.push_back(std::async(std::launch::async, []() { 
            Logger logger;
            logger.Log("Test message"); }));
    }

    // Wait for all tasks to complete
    for (auto& future : futures) {
        future.get();
    }
}

请问这是什么原因？为什么在已用std::mutex序列化操作的情况下，操作系统不会自动刷新输出，必须显式调用flush？
这是否是C++文件流的预期行为？

核心原因：每个Logger实例持有独立文件流 #

你的代码中每个异步任务都会创建独立的Logger对象，每个Logger都拥有自己的std::ofstream实例——这些实例以std::ios::app模式打开同一个文件，但彼此的缓冲区完全独立。

虽然静态std::mutex同步了Log方法的执行，但不同流的缓冲区数据不会自动同步到磁盘。当你不显式调用flush时，每个流的缓冲区只会在Logger对象析构时尝试刷新到磁盘。而多线程场景下，多个流实例的析构顺序、磁盘写入时机不可控，很可能出现部分缓冲区数据未写入就被其他流操作干扰，或者程序结束时某些缓冲区未被正确刷新，最终导致日志丢失。

显式调用flush后，每次写入都会立刻将当前流的缓冲区同步到磁盘，避免了多个独立缓冲区的冲突，因此所有日志都能正确写入。

属于C++文件流的预期行为 #

这完全是C++标准文件流的预期行为：

• 标准文件流默认采用缓冲IO，数据先写入内存缓冲区，只有当缓冲区满、流被关闭/析构，或者显式调用flush时，才会将缓冲区数据刷入磁盘。
• 多个独立流对象打开同一个文件时，它们的缓冲区相互独立，C++标准不会自动同步这些流的缓冲区状态——这种场景下必须由开发者手动保证数据一致性，要么用单例模式确保只有一个流实例，要么每次写入后显式刷新缓冲区。

修复建议：改用单例模式 #

最合理的修复方式是让Logger成为单例，确保整个程序中只有一个std::ofstream实例操作日志文件：

class Logger {
public:
    // 获取单例实例
    static Logger& GetInstance() {
        static Logger instance;
        return instance;
    }

    void Log(const std::string& message) {
        std::lock_guard lock(mtx_);
        log_file_ << std::format("{}\n", message);
        // 单例模式下即使不flush，程序结束时流析构也会自动刷新缓冲区
        // log_file_.flush(); 
    }

    // 禁止拷贝和移动
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;
    Logger(Logger&&) = delete;
    Logger& operator=(Logger&&) = delete;

private:
    Logger() : log_file_("log.txt", std::ios::app) {}
    ~Logger() = default;

    static std::mutex mtx_;
    std::ofstream log_file_;
};

std::mutex Logger::mtx_;

int main()
{
    std::vector<std::future<void>> futures;

    for (int i = 0; i < 25; ++i) {
        futures.push_back(std::async(std::launch::async, []() { 
            Logger::GetInstance().Log("Test message"); }));
    }

    for (auto& future : futures) {
        future.get();
    }
}

所有线程共用同一个文件流实例，缓冲区统一，即使不显式调用flush，程序结束时流析构也会自动刷新缓冲区，不会丢失日志；同时静态mutex依然保证了写入操作的线程安全。

内容的提问来源于stack exchange，提问作者İsa Yurdagül