C++併發實戰12：線程安全的queue

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

分類： C++併發實戰2013-12-13 15:16 793人閱讀 評論(5) 收藏 舉報

C++併發實戰11線程安全的queue

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

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接口

#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

#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();
     }
};