C++20 里那个不抢话的 syncstream：多线程打印不再“叠字”

你有没有试过多线程程序里，用 std::cout 打印几行调试信息，结果输出变成这样：

ThreTread 1 done.
ad 2 done.

不是 bug，是竞态——std::cout 本身线程安全（不会崩），但输出操作不是原子的。写入缓冲、刷屏、换行这些步骤被多个线程穿插执行，就像几个人挤在同一个麦克风前说话，词儿没乱，但顺序全糊了。

C++20 引入 std::syncstream，不是加锁的“土办法”，而是一套轻量、语义清晰的同步输出机制。它不解决所有并发问题，但专治“打印打架”这个高频痛点。

为什么 cout 会“叠字”？先看清病根

std::cout 是 std::basic_ostream<char> 的特化，底层绑定到 std::cout.tie() 关联的 std::streambuf。关键点在于：

• 每次 << 操作只保证“把数据塞进缓冲区”是线程安全的；
• 但缓冲区 flush、格式化换行、实际写入终端这些动作，并不打包成一个不可打断的单元。

举个具体例子：

// 线程 A
std::cout << "Thread A: start\n";

// 线程 B
std::cout << "Thread B: done\n";

可能的实际执行流是：
A 写 "Thread A: st" → B 写 "Thread B: do" → A 写 "art\n" → B 写 "ne\n"
→ 终端显示 "Thread A: stThread B: done\nart\n" —— 典型交错。

这不是 cout 的缺陷，而是设计使然：它默认为单线程优化，同步开销由用户按需添加。

syncstream 不是“带锁的 cout”，它是“自带排队通道”

std::syncstream 的核心不是给 cout 加 mutex，而是提供一个带隐式同步语义的包装器：

• 它内部持有一个 std::ostream&（通常是 std::cout）和一个 std::mutex；
• 每次 << 表达式结束时（即分号处），自动 lock + flush + unlock；
• 更重要的是：它重载了 operator<<，让整个表达式（哪怕链式调用）被视为一个逻辑单元。

看这段真实可用的代码：

#include <syncstream>
#include <thread>
#include <vector>

void worker(int id) {
    std::syncbuf sb{std::cout};  // 可选：显式构造 syncbuf
    std::osyncstream os{sb};     // 推荐：直接用 osyncstream

    for (int i = 0; i < 3; ++i) {
        os << "Worker " << id << " step " << i << "\n";  // ✅ 整行原子输出
    }
}

int main() {
    std::vector<std::thread> ts;
    for (int i = 0; i < 4; ++i) {
        ts.emplace_back(worker, i);
    }
    for (auto& t : ts) t.join();
}

输出永远是干净的四组完整行，不会穿插。因为 os << ... << "\n"; 这整条语句执行完毕后，才真正落盘——换行符成了原子性的句号。

注意两个细节：

• 必须以 \n 结尾（而非 std::endl），否则不会触发 flush；std::endl 强制 flush + \n，但 syncstream 的同步粒度在表达式末尾，endl 反而可能引入多余开销；
• std::osyncstream 是移动语义友好的，适合传参或返回，不用怕拷贝开销。

它不是万能胶水，但用对场景很省心

syncstream 解决的是“人类可读日志/调试输出”的一致性，不是替代 std::mutex 做业务同步。

• ✅ 适合：多线程打印状态、进度、错误摘要；单元测试中检查输出；CLI 工具的实时反馈。
• ❌ 不适合：高频性能敏感日志（每微秒打一行）、需要自定义缓冲策略、或依赖 cout.rdbuf() 直接操作底层 buffer 的场景。

一个实用技巧：把 osyncstream 封装成线程局部对象，避免反复构造：

thread_local std::osyncstream log{std::cout};
// 后续任意位置：
log << "ID " << std::this_thread::get_id() << " acquired lock\n";

thread_local + osyncstream 组合，既免去锁竞争，又保持跨线程输出不交错——比全局 mutex 更轻，比裸 cout 更稳。

别忘了：它只是 C++20 的“小工具”，不是并发银弹

syncstream 的价值，不在技术多炫，而在把一个反复踩坑的实践模式，固化为标准库的直觉接口。以前我们得手写 RAII 锁、封装 printf、甚至临时切到 write(2) 系统调用；现在一行 #include <syncstream>，加个 osyncstream，问题就收敛了。

但它不改变 cout 本身的缓冲策略，也不干涉 cerr 或文件流。如果你的程序已用 spdlog 或 glog，那 syncstream 就是备用方案，不是迁移理由。

真正该记住的，是那个判断原则：
当输出内容需要“人眼可读的完整性”，且你不愿/不能为每行加锁时——osyncstream 就是那个刚刚好、不重不轻的解决方案。

下次再看到终端里蹦出半截单词，别急着加 std::lock_guard，试试 #include <syncstream>，让输出自己排好队。