您现在的位置：程式碼之家 >> 編程語言 > >> C語言 >> 關於C語言

STL 容器線程安全深度解析：風險場景與封裝方案

編輯：關於C語言

STL 容器使用便捷、自動內存管理、配合泛型算法開發效率極高，但「肆無忌憚」地在多線程環境下使用，終將踩坑。本文基於《Effective STL》核心內容，系統梳理 STL 容器線程安全邊界，並提供工程級封裝方案。

一、線程安全場景（無需額外同步）

多讀者安全：多線程同時只讀同一容器內容，正確執行。前提：讀取期間無任何寫入操作。
不同容器多寫入者安全：多線程同時操作不同容器實例，互不干擾。

二、線程不安全場景（必須加鎖）

同一容器多線程讀寫/寫寫：任何對同一容器的並發修改、或讀寫並發
成員函數調用期間：每次調用容器成員函數（如 push_back、size、operator[]）必須鎖定該容器
迭代器生存期內：從 begin()/end() 獲取迭代器起，直到迭代器銷毀，必須鎖定容器
算法執行期間：在容器上調用標準算法（如 sort、find、for_each）整個執行期間必須鎖定容器

核心洞見：STL 容器不提供任何內建同步機制。迭代器失效、內部結構調整（如 vector 擴容、map 紅黑樹旋轉）在併發下極易導致數據競爭、崩潰或未定義行為。

三、工程實戰：通用線程安全封裝方案

方案一：RAII 鎖包裝器（推薦）

template <typename Container>
class ContainerLock {
public:
    explicit ContainerLock(Container& c) : container_(c) {
        mutex_.lock();  // 構造時加鎖
    }
    ~ContainerLock() {
        mutex_.unlock(); // 析構時解鎖，異常安全
    }
    // 禁止拷貝，允許移動
    ContainerLock(const ContainerLock&) = delete;
    ContainerLock& operator=(const ContainerLock&) = delete;
    
    Container& get() { return container_; }
private:
    Container& container_;
    static std::mutex mutex_; // 每個容器類型一把鎖，或每實例一把鎖
};

// 使用示例
std::vector<int> vec;
{
    ContainerLock<std::vector<int>> lock(vec);
    auto& safe_vec = lock.get();
    safe_vec.push_back(42); // 安全操作
    // 離開作用域自動解鎖
}

方案二：繼承式封裝（侵入式）

template <typename T>
class ThreadSafeVector : private std::vector<T>> {
    mutable std::mutex mtx_;
public:
    void push_back(const T& val) {
        std::lock_guard<std::mutex> lock(mtx_);
        std::vector<T>::push_back(val);
    }
    size_t size() const {
        std::lock_guard<std::mutex> lock(mtx_);
        return std::vector<T>::size();
    }
    // ... 需暴露的每個接口都要包裹
};

方案三：策略模式注入鎖（靈活）

template <typename Container, typename LockPolicy = std::mutex>
class SynchronizedContainer {
    Container c_;
    mutable LockPolicy mtx_;
public:
    template <typename Func>
    auto apply(Func&& f) const -> decltype(f(c_)) {
        std::lock_guard<LockPolicy> lock(mtx_);
        return f(c_);
    }
};

// 使用
SynchronizedContainer<std::map<int, std::string>> safe_map;
safe_map.apply([](auto& m) { m[1] = "thread-safe"; });

四、典型應用場景：生產者-消費者隊列

使用 std::queue 或 std::deque 做共享任務隊列時，必須封裝：

template <typename T>
class ThreadSafeQueue {
    std::deque<T> q_;
    mutable std::mutex mtx_;
    std::condition_variable cv_;
public:
    void push(T val) {
        std::lock_guard<std::mutex> lock(mtx_);
        q_.push_back(std::move(val));
        cv_.notify_one();
    }
    bool try_pop(T& val) {
        std::lock_guard<std::mutex> lock(mtx_);
        if (q_.empty()) return false;
        val = std::move(q_.front());
        q_.pop_front();
        return true;
    }
    void wait_pop(T& val) {
        std::unique_lock<std::mutex> lock(mtx_);
        cv_.wait(lock, [this]{ return !q_.empty(); });
        val = std::move(q_.front());
        q_.pop_front();
    }
};