c++阻塞队列

基于C++11的阻塞队列简单实现

     转载请说明出处：http://blog.csdn.net/cywosp/article/details/9157379

     在多线程编程中阻塞队列(Blocking Queue)是一种常用于实现生产者和消费者模型的数据结构。其与普通的队列区别在于，当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中被放入了元素；当队列满时，往队列里存放元素的操作也会被阻塞，直到有元素被从队列中取出(以上的操作都是基于不同的线程来说的，线程在对阻塞队列进程操作时会被阻塞)。下图展示如何通过阻塞队列来合作：

                             

接下来我们用C++11来实现一个简单的阻塞队列（没有容量限制的BlockingQueue）

[cpp]  view plain  copy

1. template<typename T>  
2. class BlockingQueue  
3. {  
4. public:  
5.     BlockingQueue () : _mutex (), _condvar (), _queue ()  
6.     {  
7.   
8.     }  
9.   
10.     void Put (const T& task)  
11.     {  
12.         {  
13.             std::lock_guard<std::mutex> lock (_mutex);  
14.             _queue.push_back (task);  
15.         }  
16.         _condvar.notify_all ();  
17.     }  
18.   
19.     T Take ()  
20.     {  
21.         std::unique_lock<std::mutex> lock (_mutex);  
22.         _condvar.wait (lock, [this]{return !_queue.empty ();});  
23.         assert (!_queue.empty ());  
24.         T front (_queue.front ());  
25.         _queue.pop_front ();  
26.   
27.         return front;  
28.     }  
29.   
30.     size_t Size() const  
31.     {  
32.         std::lock_guard<std::mutex> lock (_mutex);  
33.         return _queue.size();  
34.     }  
35.   
36. private:  
37.     BlockingQueue (const BlockingQueue& rhs);  
38.     BlockingQueue& operator = (const BlockingQueue& rhs);  
39.   
40. private:  
41.     mutable std::mutex _mutex;  
42.     std::condition_variable _condvar;  
43.     std::list<T> _queue;  
44. };  

注：以上代码需要加入下列头文件

#include <condition_variable>

#include <list>

#include <assert.h>

编译时需要加入编译选项 -std=c++0x或者-std=c++11

简单测试程序如下：

将上述代码放到 BlockingQueue.hpp文件中

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <thread>  
3. #include <future>  
4. #include "BlockingQueue.hpp"  
5.   
6. int main (int argc, char* argv[])  
7. {  
8.     BlockingQueue<int> q;  
9.     auto t1 = std::async (std::launch::async, [&q] () {  
10.         for (int i = 0; i < 10; ++i) {  
11.             q.Put (i);  
12.         }  
13.     });  
14.   
15.     auto t2 = std::async (std::launch::async, [&q] () {  
16.         while (q.Size ()) {  
17.             std::cout << q.Take () << std::endl;  
18.         }  
19.     });  
20.   
21.     auto t3 = std::async (std::launch::async, [&q] () {  
22.         while (q.Size ()) {  
23.             std::cout << q.Take () << std::endl;  
24.         }  
25.     });  
26.   
27.     t1.wait ();  
28.     t2.wait ();  
29.     t3.wait ();  
30.   
31.     return 0;  
32. }  

编译： g++ -o blockingqueue -std=c++11 main.cpp BlockingQueue.hpp -pthread

执行blockingqueue得如下结果：

10

23

4

5

6

7

8

9

本篇文章只是简单的实现了阻塞队列的插入函数与获取函数，在java中有线程的BlockingQueue容器可以直接使用，其提供了很多有用的函数（欲知请Google）。