C++ `std::cout` 在多线程环境下的线程安全性与性能

好的，没问题。

各位老铁，今天咱们聊聊C++里那个让人又爱又恨的std::cout。啥？你觉得它简单？呵呵，那是因为你还没在多线程的环境下好好“伺候”过它。别急，今天就带你好好盘一盘这玩意儿在多线程下的线程安全性和性能问题。

开场白：std::cout，一个“老实人”的自白

std::cout，咱们C++程序员的老朋友，往屏幕上打印点啥，第一个想到的就是它。但它本质上就是一个全局对象，背后连着标准输出流。在单线程的世界里，它兢兢业业，你给它啥，它就吐啥，从来不含糊。可一旦到了多线程的环境，它就有点懵圈了。

想象一下，一群线程嗷嗷待哺，都想往std::cout里塞点东西。如果没有协调好，你一句，我一句，最后输出的结果可能就是一锅粥，乱七八糟，不堪入目。这就是线程安全问题。

线程安全性：std::cout的“社交恐惧症”

啥是线程安全？简单来说，就是多个线程同时访问一个共享资源（比如std::cout），不会导致数据错乱或者程序崩溃。 std::cout默认情况下，并非完全线程安全。换句话说，它有“社交恐惧症”，不太擅长应付多线程这种“社交场合”。

具体来说， std::cout 的 operator<< 操作符，通常不是原子操作。也就是说，一个完整的输出过程，可能被拆分成多个步骤。在多线程环境下，如果两个线程同时调用 std::cout << "Hello" << "World"，可能出现以下情况：

线程1输出了 "Hello"，然后被线程2抢占。
线程2输出了 "Goodbye"，然后线程1继续输出 "World"。
最终屏幕上显示的是 "HelloGoodbyeWorld"，或者是 "GoodbyeHelloWorld"，反正就是乱了。

为了验证这一点，咱们来搞个小实验：

#include <iostream>
#include <thread>
#include <chrono>

void print_message(int id) {
    for (int i = 0; i < 1000; ++i) {
        std::cout << "Thread " << id << ": Message " << i << std::endl;
        //std::this_thread::sleep_for(std::chrono::microseconds(10)); // 稍微延迟一下，更容易观察到线程安全问题
    }
}

int main() {
    std::thread t1(print_message, 1);
    std::thread t2(print_message, 2);

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

    return 0;
}

运行这段代码，你会发现，输出的结果很可能不是你想要的。 Thread 1 和 Thread 2 的消息交织在一起，乱七八糟。这就是 std::cout 在多线程环境下不安全的典型表现。

如何让std::cout“克服社恐”？线程安全的解决方案

既然 std::cout 有“社恐”，那我们就得帮它一把，让它在多线程环境下也能正常工作。常用的方法有两种：

互斥锁（Mutex）： 给 std::cout 加个“保护罩”，每次只有一个线程能访问它。
自定义流缓冲区： 把所有线程的输出都先放到自己的“小仓库”里，最后再统一交给 std::cout。

咱们先来看看互斥锁的方案：

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

std::mutex cout_mutex; // 定义一个互斥锁，专门用来保护 std::cout

void print_message_safe(int id) {
    for (int i = 0; i < 1000; ++i) {
        std::lock_guard<std::mutex> lock(cout_mutex); // 获取锁，离开作用域自动释放
        std::cout << "Thread " << id << ": Message " << i << std::endl;
    }
}

int main() {
    std::thread t1(print_message_safe, 1);
    std::thread t2(print_message_safe, 2);

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

    return 0;
}

在这个例子中，我们定义了一个 std::mutex 对象 cout_mutex。在 print_message_safe 函数中，我们使用 std::lock_guard 来获取锁。 std::lock_guard 是一个RAII（Resource Acquisition Is Initialization）风格的锁，它会在构造时获取锁，在析构时自动释放锁，避免了手动释放锁的麻烦。

现在再运行这段代码，你会发现，输出的结果变得整齐多了。 Thread 1 和 Thread 2 的消息不再交织在一起，而是各自完整地输出。

接下来，咱们看看自定义流缓冲区的方案：

#include <iostream>
#include <sstream>
#include <thread>
#include <vector>

void print_message_buffered(int id) {
    std::stringstream ss; // 每个线程创建一个stringstream
    for (int i = 0; i < 1000; ++i) {
        ss << "Thread " << id << ": Message " << i << std::endl;
    }
    std::cout << ss.str(); // 最后一次性输出
}

int main() {
    std::thread t1(print_message_buffered, 1);
    std::thread t2(print_message_buffered, 2);

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

    return 0;
}

在这个例子中，每个线程都使用自己的 std::stringstream 对象来缓存输出。最后，每个线程将自己的 stringstream 中的内容一次性输出到 std::cout。这种方式也可以保证输出的线程安全。

性能考量：鱼和熊掌不可兼得？

虽然互斥锁和自定义流缓冲区都可以解决 std::cout 的线程安全问题，但它们也带来了一定的性能损失。

互斥锁： 每次访问 std::cout 都需要获取和释放锁，这会增加额外的开销。特别是在高并发的情况下，锁的竞争会非常激烈，导致线程阻塞，降低程序的整体性能。
自定义流缓冲区： 需要额外的内存来存储每个线程的输出。而且，最后一次性输出时，可能会导致较大的延迟。

那么，到底哪种方案更好呢？这取决于你的具体应用场景。

方案	优点	缺点	适用场景
互斥锁	简单易用，代码改动小。	性能开销大，在高并发情况下竞争激烈。	对性能要求不高，或者并发量不大的情况。
自定义流缓冲区	可以减少锁的竞争，提高并发性能。	需要额外的内存，可能会导致延迟。	对性能要求较高，但可以容忍一定的延迟的情况。

更高级的玩法：自定义流缓冲区 + 锁

有时候，我们需要兼顾线程安全和性能。这时候，可以考虑将自定义流缓冲区和锁结合起来使用。具体来说，就是每个线程使用自己的 stringstream 对象来缓存输出，然后在输出到 std::cout 时，使用锁来保证线程安全。

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

std::mutex cout_mutex;

void print_message_hybrid(int id) {
    std::stringstream ss;
    for (int i = 0; i < 1000; ++i) {
        ss << "Thread " << id << ": Message " << i << std::endl;
    }

    {
        std::lock_guard<std::mutex> lock(cout_mutex);
        std::cout << ss.str();
    }
}

int main() {
    std::thread t1(print_message_hybrid, 1);
    std::thread t2(print_message_hybrid, 2);

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

    return 0;
}

这种方案的优点是可以减少锁的竞争，提高并发性能。同时，也可以保证输出的线程安全。

最佳实践：根据场景选择合适的方案

说了这么多，到底该怎么选择呢？记住，没有银弹。你需要根据你的具体应用场景，选择最合适的方案。

如果你的程序并发量不大，对性能要求不高，那么直接使用互斥锁是最简单的选择。
如果你的程序并发量很大，对性能要求很高，那么可以考虑使用自定义流缓冲区或者自定义流缓冲区 + 锁的方案。
如果你的程序需要实时性很高，不能容忍延迟，那么可以考虑使用其他线程安全的日志库，比如spdlog，或者glog。 这些库通常会提供更高效的线程安全机制。

总结：std::cout，且用且珍惜

std::cout 确实是个好东西，用起来简单方便。但在多线程环境下，一定要小心使用，避免踩坑。记住，线程安全性和性能是需要权衡的。选择最适合你的方案，才能让你的程序跑得更快，更稳。

好了，今天的分享就到这里。希望对你有所帮助。记住，编程的世界里，没有绝对的真理，只有不断学习和实践。祝各位老铁编码愉快！

发表回复 取消回复

发表回复取消回复