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

  http://blog.youkuaiyun.com/liuxuejiang158blog/article/details/17301739

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

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

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

[cpp]  view plain copy

1. template <class T, class Container = std::deque<T> >  
2. class queue {  
3.   public:  
4.     explicit queue(const Container&);  
5.     explicit queue(Container&& = Container());  
6.     template <class Alloc> explicit queue(const Alloc&);  
7.     template <class Alloc> queue(const Container&, const Alloc&);  
8.     template <class Alloc> queue(Container&&, const Alloc&);  
9.     template <class Alloc> queue(queue&&, const Alloc&);  
10.     void swap(queue& q);  
11.     bool empty() const;  
12.     size_type size() const;  
13.     T& front();  
14.     const T& front() const;  
15.     T& back();  
16.     const T& back() const;  
17.     void push(const T& x);  
18.     void push(T&& x);  
19.     void pop();  
20.     template <class... Args> void emplace(Args&&... args);  
21. };  

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

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

[cpp]  view plain copy

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

3 实现threadsafe_queue

[cpp]  view plain copy

1. #include <queue>  
2. #include <memory>  
3. #include <mutex>  
4. #include <condition_variable>  
5. template<typename T>  
6. class threadsafe_queue  
7. {  
8.   private:  
9.      mutable std::mutex mut;   
10.      std::queue<T> data_queue;  
11.      std::condition_variable data_cond;  
12.   public:  
13.      threadsafe_queue(){}  
14.      threadsafe_queue(threadsafe_queue const& other)  
15.      {  
16.          std::lock_guard<std::mutex> lk(other.mut);  
17.          data_queue=other.data_queue;  
18.      }  
19.      void push(T new_value)//入队操作  
20.      {  
21.          std::lock_guard<std::mutex> lk(mut);  
22.          data_queue.push(new_value);  
23.          data_cond.notify_one();  
24.      }  
25.      void wait_and_pop(T& value)//直到有元素可以删除为止  
26.      {  
27.          std::unique_lock<std::mutex> lk(mut);  
28.          data_cond.wait(lk,[this]{return !data_queue.empty();});  
29.          value=data_queue.front();  
30.          data_queue.pop();  
31.      }  
32.      std::shared_ptr<T> wait_and_pop()  
33.      {  
34.          std::unique_lock<std::mutex> lk(mut);  
35.          data_cond.wait(lk,[this]{return !data_queue.empty();});  
36.          std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));  
37.          data_queue.pop();  
38.          return res;  
39.      }  
40.      bool try_pop(T& value)//不管有没有队首元素直接返回  
41.      {  
42.          std::lock_guard<std::mutex> lk(mut);  
43.          if(data_queue.empty())  
44.              return false;  
45.          value=data_queue.front();  
46.          data_queue.pop();  
47.          return true;  
48.      }  
49.      std::shared_ptr<T> try_pop()  
50.      {  
51.          std::lock_guard<std::mutex> lk(mut);  
52.          if(data_queue.empty())  
53.              return std::shared_ptr<T>();  
54.          std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));  
55.          data_queue.pop();  
56.          return res;  
57.      }  
58.      bool empty() const  
59.      {  
60.          std::lock_guard<std::mutex> lk(mut);  
61.          return data_queue.empty();  
62.      }  
63. };