第7章线程安全容器

课程目录第7章线程安全容器

7、线程安全容器：从理论到实战

各位同学，咱们今天来聊聊线程安全容器。说实话，这部分内容在实际项目中太常用了。我早期做后台服务时，就因为在多线程环境下直接用了 std::queue，结果线上出了诡异的数据错乱。排查了整整两天，最后发现是队列的 push 和 pop 没有加锁。嗯，从那以后，我对线程安全容器就格外上心。

你想想看，多线程编程里，数据竞争是头号大敌。而容器，恰恰是数据最集中的地方。所以，怎么让容器在多线程环境下安全又高效地工作，就成了我们必须掌握的技能。

核心要点：线程安全容器的本质，就是在标准容器的基础上，通过合理的同步机制（锁、原子操作等），保证多个线程同时访问时数据的一致性和完整性。

7.1 线程安全队列的实现

队列，先进先出，这个大家都熟。但在多线程环境下，事情就没那么简单了。我见过很多新手直接给 std::queue 的每个操作都加一把大锁。这样做虽然安全，但性能很差。说白了，就是锁的粒度太粗了。

我个人习惯的做法是：分离锁。什么意思呢？就是让 push 和 pop 操作尽量不互相阻塞。比如，我们可以用两个互斥量，一个保护队列头，一个保护队列尾。当然，这需要底层数据结构支持，比如用链表实现队列。

下面是一个基于 std::queue 和 std::mutex 的简单实现，适合大多数场景：

#include <queue>
#include <mutex>
#include <condition_variable>

template<typename T>
class ThreadSafeQueue {
private:
    mutable std::mutex mut;
    std::queue<T> data_queue;
    std::condition_variable data_cond;
public:
    ThreadSafeQueue() {}

    void push(T new_value) {
        std::lock_guard<std::mutex> lk(mut);
        data_queue.push(std::move(new_value));
        data_cond.notify_one();
    }

    void wait_and_pop(T& value) {
        std::unique_lock<std::mutex> lk(mut);
        data_cond.wait(lk, [this]{return !data_queue.empty();});
        value = std::move(data_queue.front());
        data_queue.pop();
    }

    std::shared_ptr<T> wait_and_pop() {
        std::unique_lock<std::mutex> lk(mut);
        data_cond.wait(lk, [this]{return !data_queue.empty();});
        std::shared_ptr<T> res(
            std::make_shared<T>(std::move(data_queue.front())));
        data_queue.pop();
        return res;
    }

    bool try_pop(T& value) {
        std::lock_guard<std::mutex> lk(mut);
        if (data_queue.empty())
            return false;
        value = std::move(data_queue.front());
        data_queue.pop();
        return true;
    }

    std::shared_ptr<T> try_pop() {
        std::lock_guard<std::mutex> lk(mut);
        if (data_queue.empty())
            return std::shared_ptr<T>();
        std::shared_ptr<T> res(
            std::make_shared<T>(std::move(data_queue.front())));
        data_queue.pop();
        return res;
    }

    bool empty() const {
        std::lock_guard<std::mutex> lk(mut);
        return data_queue.empty();
    }
};

避坑指南：我曾经在 empty() 函数上吃过亏。记住，empty() 返回的只是调用瞬间的状态。在多线程环境下，你刚判断完队列非空，另一个线程可能就把最后一个元素取走了。所以，empty() 通常只用于调试或非关键判断，真正的业务逻辑应该用 try_pop 或 wait_and_pop。

7.2 线程安全栈的实现

栈，后进先出。实现线程安全栈的思路和队列类似，但有一个关键区别：栈的 pop 操作通常需要返回被弹出的元素。这就带来了一个异常安全问题：如果拷贝构造函数抛出异常，元素就丢了。

我建议的解决方案是：pop 返回 std::shared_ptr，或者传入一个引用参数。这样即使拷贝失败，原始数据还在栈里。

#include <stack>
#include <mutex>

template<typename T>
class ThreadSafeStack {
private:
    std::stack<T> data;
    mutable std::mutex mut;
public:
    ThreadSafeStack() {}

    void push(T new_value) {
        std::lock_guard<std::mutex> lk(mut);
        data.push(std::move(new_value));
    }

    std::shared_ptr<T> pop() {
        std::lock_guard<std::mutex> lk(mut);
        if (data.empty()) return std::shared_ptr<T>();
        std::shared_ptr<T> res(
            std::make_shared<T>(std::move(data.top())));
        data.pop();
        return res;
    }

    void pop(T& value) {
        std::lock_guard<std::mutex> lk(mut);
        if (data.empty()) throw std::runtime_error("empty stack");
        value = std::move(data.top());
        data.pop();
    }

    bool empty() const {
        std::lock_guard<std::mutex> lk(mut);
        return data.empty();
    }
};

注意：上面的 pop(T& value) 版本，如果拷贝赋值抛出异常，栈顶元素已经被 std::move 移走了，数据会丢失。所以，我更推荐使用返回 std::shared_ptr 的版本。这是我在实际项目中踩过的坑，分享给大家。

7.3 读写锁（shared_mutex）

读多写少的场景，用普通的互斥锁太浪费了。你想想看，如果多个线程只是读数据，它们完全可以同时进行，没必要互相等待。这时候，读写锁就派上用场了。

C++17 提供了 std::shared_mutex。它有两种锁模式：std::shared_lock（共享锁，用于读）和 std::unique_lock（独占锁，用于写）。多个线程可以同时持有共享锁，但独占锁会阻塞所有其他锁。

#include <shared_mutex>
#include <map>
#include <string>

class ThreadSafeDictionary {
private:
    mutable std::shared_mutex rw_mutex;
    std::map<std::string, std::string> dict;
public:
    // 读操作：多个线程可以同时调用
    std::string read(const std::string& key) const {
        std::shared_lock<std::shared_mutex> lock(rw_mutex);
        auto it = dict.find(key);
        if (it != dict.end()) {
            return it->second;
        }
        return "";
    }

    // 写操作：独占
    void write(const std::string& key, const std::string& value) {
        std::unique_lock<std::shared_mutex> lock(rw_mutex);
        dict[key] = value;
    }
};

个人经验：我在一个配置中心服务里用过 shared_mutex。配置数据几乎不变，但每秒有上千次读取。用读写锁后，性能提升了近 5 倍。但要注意，如果写操作很频繁，读写锁反而可能比普通互斥锁慢，因为锁的管理开销更大。

7.4 并发容器的设计原则

说了这么多具体实现，我们来总结一下设计并发容器的几个核心原则。这些是我多年摸爬滚打总结出来的，希望能帮你少走弯路。

最小化锁的粒度：只锁真正需要保护的数据。比如，队列的 push 和 pop 如果操作的是不同内存区域，可以考虑用不同的锁。
避免锁嵌套：一个线程持有一个锁时，不要再尝试获取另一个锁。否则很容易死锁。如果实在避免不了，用 std::lock 一次性锁定多个互斥量。
接口设计要安全：比如 pop 操作，尽量设计成要么返回 shared_ptr，要么传入引用。避免在锁外访问已经被释放的元素。
考虑异常安全：锁本身是 RAII 的，但容器内的数据操作可能抛异常。确保异常发生时，容器处于一个一致的状态。
优先使用标准库：C++ 标准库提供了 std::shared_mutex、std::atomic 等工具。不要自己造轮子，除非你很清楚自己在做什么。

总结一下：线程安全容器的设计，本质上是在「安全性」和「性能」之间找平衡。没有银弹，只有根据具体场景做权衡。我个人的建议是：先从简单的全锁版本开始，性能不够时再考虑优化。过早优化是万恶之源。

好了，关于线程安全容器，我们就聊到这里。记住，理论是基础，但真正的理解来自实践。我建议你亲手实现一遍上面的队列和栈，然后写个多线程测试程序跑一跑。遇到问题不要怕，那是成长最快的时候。

📚 课程目录

7、线程安全容器：从理论到实战

7.1 线程安全队列的实现

7.2 线程安全栈的实现

7.3 读写锁（shared_mutex）

7.4 并发容器的设计原则