使用C++写线程安全队列

引

• STL的容不是线程安全的，我们经常会有需求要求数据结构线程安全，比如写生产者消费者模型的时候，就要求队列线程安全。
• 利用std::queue和C++线程标准库的一些组件（mutex，condition_variable），可以写一个线程安全的队列ConcurrenceQueue

定义基本结构

需要4个函数

• push，入队；
• pop，出队并返回原来对头的元素，如果为队空则阻塞；
• tryPop，出队并返回原来对头的元素，如果队空返回空（使用智能指针作返回类型）；
• empty，返回是否为空，实则没啥用，多线程条件下判空，下一瞬间另一线程就可能push进去东西了。

template<typename DATATYPE, typename SEQUENCE = std::deque<DATATYPE>>
class ConcurrenceQueue {
public:
    ConcurrenceQueue();
    
    ConcurrenceQueue(const ConcurrenceQueue & other);
    
    ConcurrenceQueue(ConcurrenceQueue &&) = delete;
    ConcurrenceQueue & operator= (const ConcurrenceQueue &) = delete;
    
    ~ConcurrenceQueue() = default;
    
    bool empty() const;
    
    void push(const DATATYPE & data);
    
    void push(DATATYPE && data);
    
    std::shared_ptr<DATATYPE> tryPop(); // 非阻塞
    
    std::shared_ptr<DATATYPE> pop();  // 阻塞

private:
    std::queue<DATATYPE, SEQUENCE> m_data;  // 底层数据结构
    mutable std::mutex m_mutex;  // 互斥量
    std::condition_variable m_cond;  // 条件变量, 在push元素进去时通知
};

实现

• push, 直接加锁, push完成后通知一个等待m_cond的函数；

void push(const DATATYPE & data) {
    std::lock_guard<std::mutex> lg(m_mutex);
    m_data.push(data);
    m_cond.notify_one();
}

void push(DATATYPE && data) {
    std::lock_guard<std::mutex> lg(m_mutex);
    m_data.push(std::move(data));
    m_cond.notify_one();
}

• pop, 条件变量, 空时阻塞(wait), 否则pop并返回原来队头元素；

std::shared_ptr<DATATYPE> pop() {  // 非阻塞
    std::unique_lock<std::mutex> lg(m_mutex);
    m_cond.wait(lg, [this] { return !m_data.empty(); });
    auto res = std::make_shared<DATATYPE>(std::move(m_data.front()));
    m_data.pop();
    return res;
}

• tryPop, 直接加锁, 空则返回空并解锁, 否则pop并返回原来队头元素；

std::shared_ptr<DATATYPE> tryPop() {  // 非阻塞
    std::lock_guard<std::mutex> lg(m_mutex);
    if (m_data.empty()) return {};
    auto res = std::make_shared<DATATYPE>(m_data.front());
    m_data.pop();
    return res;
}

• empty, 直接加锁, 判断底层数据结构是否为空并返回。

bool empty() const {
    std::lock_guard<std::mutex> lg(m_mutex);
    return m_data.empty();
}

测试

• 全局队列和一些函数

ConcurrenceQueue<int> g_queue;

void producer() {    
    for (int i = 0; i < 100; ++i) {
        g_queue.push(i);
        std::this_thread::sleep_for(std::chrono::seconds(3));
    }
}
void consumer1() {
    while (1) {
        std::printf("[1]  -------   %d\n", *g_queue.pop());
    }
}
void consumer2() {
    while (1) {
        auto front = g_queue.tryPop();
        std::printf("[2]  -------   %d\n", front ? *front : -1);
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}

• 测试一

int main () {
    std::thread t1(producer);
    std::thread t2(consumer1);

    t1.join();
    t2.join();
    return 0;
}

• 测试二

int main () {
    std::thread t1(producer);
    std::thread t2(consumer2);

    t1.join();
    t2.join();
    return 0;
}

• 测试结果

ConcurrenceQueue全部代码

#ifndef __CONCURRENCEQUEUE_H__
#define __CONCURRENCEQUEUE_H__
#include <mutex>
#include <condition_variable>
#include <deque>
#include <queue>
#include <memory>

template<typename DATATYPE, typename SEQUENCE = std::deque<DATATYPE>>
class ConcurrenceQueue {
public:
    ConcurrenceQueue() = default;
    
    ConcurrenceQueue(const ConcurrenceQueue & other) {
        std::lock_guard<std::mutex> lg(other.m_mutex);
        m_data = other.m_data;
    }
    ConcurrenceQueue(ConcurrenceQueue &&) = delete;
    ConcurrenceQueue & operator= (const ConcurrenceQueue &) = delete;
    ~ConcurrenceQueue() = default;
    bool empty() const {
        std::lock_guard<std::mutex> lg(m_mutex);
        return m_data.empty();
    }
    
    void push(const DATATYPE & data) {
        std::lock_guard<std::mutex> lg(m_mutex);
        m_data.push(data);
        m_cond.notify_one();
    }
    
    void push(DATATYPE && data) {
        std::lock_guard<std::mutex> lg(m_mutex);
        m_data.push(std::move(data));
        m_cond.notify_one();
    }
    
    std::shared_ptr<DATATYPE> tryPop() {  // 非阻塞
        std::lock_guard<std::mutex> lg(m_mutex);
        if (m_data.empty()) return {};
        auto res = std::make_shared<DATATYPE>(m_data.front());
        m_data.pop();
        return res;
    }
    
    std::shared_ptr<DATATYPE> pop() {  // 非阻塞
        std::unique_lock<std::mutex> lg(m_mutex);
        m_cond.wait(lg, [this] { return !m_data.empty(); });
        auto res = std::make_shared<DATATYPE>(std::move(m_data.front()));
        m_data.pop();
        return res;
    }
    
private:
    std::queue<DATATYPE, SEQUENCE> m_data;
    mutable std::mutex m_mutex;
    std::condition_variable m_cond;
};
#endif