C++并发实战12：线程安全的queue

来源：互联网发布：algorithm 风格算法编辑：程序博客网时间：2024/06/06 03:03

http://blog.csdn.net/liuxuejiang158blog/article/details/17301739

分类： C++并发实战2013-12-13 15:16 793人阅读评论(5) 收藏举报

C++并发实战11线程安全的queue

1 首先看下STL中的queue的接口：

[cpp] view plaincopy
template <class T, class Container = std::deque<T> >  
class queue {  
  public:  
    explicit queue(const Container&);  
    explicit queue(Container&& = Container());  
    template <class Alloc> explicit queue(const Alloc&);  
    template <class Alloc> queue(const Container&, const Alloc&);  
    template <class Alloc> queue(Container&&, const Alloc&);  
    template <class Alloc> queue(queue&&, const Alloc&);  
    void swap(queue& q);  
    bool empty() const;  
    size_type size() const;  
    T& front();  
    const T& front() const;  
    T& back();  
    const T& back() const;  
    void push(const T& x);  
    void push(T&& x);  
    void pop();  
    template <class... Args> void emplace(Args&&... args);  
};  

STL中的queue是非线程安全的，一个组合操作：front(); pop()先读取队首元素然后删除队首元素，若是有多个线程执行这个组合操作的话，可能会发生执行序列交替执行，导致一些意想不到的行为。因此需要重新设计线程安全的queue的接口。

2 简化的线程安全的queue接口

[cpp] view plaincopy
#include <memory>   
template<typename T>  
class threadsafe_queue  
{  
  public:  
    threadsafe_queue();  
    threadsafe_queue(const threadsafe_queue&);  
    threadsafe_queue& operator=(const threadsafe_queue&) = delete;//禁止赋值操作是为了简化   
    void push(T new_value);  
    bool try_pop(T& value);//尝试删除队首元素，若删除成功则通过value返回队首元素，并返回true;若队为空，则返回false   
    std::shared_ptr<T> try_pop();//若队非空shared_ptr返回并删除的队首元素;若队空，则返回的shared_ptr为NULL  
    void wait_and_pop(T& value);//若队非空，通过value返回队首元素并删除，函数返回true;若队为空，则通过condition_variable等待有元素入队后再获取闭并删除队首元素  
    std::shared_ptr<T> wait_and_pop();//和前面一样，只不过通过shared_ptr返回队首元素  
    bool empty() const;  
};  

3 实现threadsafe_queue

[cpp] view plaincopy
#include <queue>  
#include <memory>  
#include <mutex>  
#include <condition_variable>  
template<typename T>  
class threadsafe_queue  
{  
  private:  
     mutable std::mutex mut;   
     std::queue<T> data_queue;  
     std::condition_variable data_cond;  
  public:  
     threadsafe_queue(){}  
     threadsafe_queue(threadsafe_queue const& other)  
     {  
         std::lock_guard<std::mutex> lk(other.mut);  
         data_queue=other.data_queue;  
     }  
     void push(T new_value)//入队操作  
     {  
         std::lock_guard<std::mutex> lk(mut);  
         data_queue.push(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=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>(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=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>(data_queue.front()));  
         data_queue.pop();  
         return res;  
     }  
     bool empty() const  
     {  
         std::lock_guard<std::mutex> lk(mut);  
         return data_queue.empty();  
     }  
};  

0 0