多线程下异步Logger线程安全问题：如何保证operator<<调用的原子性？

这个问题我之前也碰到过！多线程下用<<链式输出时的内容交错，本质是因为每一次operator<<调用都是独立的操作，没有被原子化——线程1刚输出"Hello "，线程2就插进来输出"2 "，自然就乱了。

想要保留<<的自然使用方式，同时保证整个输出语句的原子性，最优雅的方案是用临时对象捕获整个输出链，在临时对象析构时再原子化输出所有内容。下面给你具体实现思路和代码：

核心思路 #

C++中，一条链式<<语句里的临时对象会在整个表达式结束后才销毁。我们可以利用这个特性：

1. 让Logger的operator<<返回一个临时的辅助对象（比如LogStream）
2. 所有<<的内容先缓存到这个辅助对象里
3. 当辅助对象析构时，再给Logger加锁，一次性输出所有缓存内容

这样整个链式输出的语句就变成了原子操作，不会被其他线程打断。

完整代码实现 #

#include <iostream>
#include <sstream>
#include <mutex>
#include <thread>

class Logger {
private:
    std::mutex m_output_mutex;
    std::ostream& m_target_stream;

public:
    Logger(std::ostream& output = std::cout) : m_target_stream(output) {}

    // 辅助类：负责捕获所有输出内容，析构时原子输出
    class LogStream {
    private:
        Logger& m_parent_logger;
        std::ostringstream m_buffer;

    public:
        explicit LogStream(Logger& logger) : m_parent_logger(logger) {}

        // 禁止拷贝，允许移动（避免不必要的开销）
        LogStream(const LogStream&) = delete;
        LogStream& operator=(const LogStream&) = delete;
        LogStream(LogStream&&) = default;
        LogStream& operator=(LogStream&&) = default;

        // 重载所有类型的operator<<，缓存内容
        template<typename T>
        LogStream& operator<<(const T& value) {
            m_buffer << value;
            return *this;
        }

        // 处理endl、flush这类流操纵符
        LogStream& operator<<(std::ostream& (*manip)(std::ostream&)) {
            m_buffer << manip;
            return *this;
        }

        // 析构时加锁，一次性输出所有缓存内容
        ~LogStream() {
            std::lock_guard<std::mutex> lock(m_parent_logger.m_output_mutex);
            m_parent_logger.m_target_stream << m_buffer.str();
        }
    };

    // Logger的operator<<：创建临时LogStream并传入第一个输出值
    template<typename T>
    LogStream operator<<(const T& value) {
        LogStream stream(*this);
        stream << value;
        return stream;
    }

    // 处理流操纵符的重载版本
    LogStream operator<<(std::ostream& (*manip)(std::ostream&)) {
        LogStream stream(*this);
        stream << manip;
        return stream;
    }
};

// 测试代码
int main() {
    Logger logger;

    std::thread t1([&logger]() {
        for (int i = 0; i < 3; ++i) {
            logger << "Hello from Thread #1 - Count: " << i << std::endl;
        }
    });

    std::thread t2([&logger]() {
        for (int i = 0; i < 3; ++i) {
            logger << "Hello from Thread #2 - Count: " << i << std::endl;
        }
    });

    t1.join();
    t2.join();

    return 0;
}

为什么这个方案有效？ #

• 你完全不用改变原有使用习惯，还是像之前一样写logger << "Hello " << 1 << std::endl;
• 整个链式语句的所有内容会被缓存到临时的LogStream对象中，直到语句结束时才会触发析构
• 析构时用std::lock_guard自动加锁，保证输出过程不会被其他线程打断，彻底避免内容交错

有没有更简便的方案？ #

其实这个方案已经是最简便且符合C风格的了。如果尝试直接在Logger的operator<<里加锁，会导致每一次<<都加锁解锁，依然可能出现交错（比如logger << "A" << "B"会分成两次锁操作，中间可能被插入）。而用宏实现虽然能凑效，但会丢失类型安全，也不符合现代C的编码习惯。

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