双缓冲队列-减少生产者消费者锁的调用

在生产者-消费者模式中，我们常常会使用到队列，这个队列在多个线程共享访问时存在互斥和竞争操作, 意味着每次访问都要加锁。如何更好的如何减少锁竞争次数呢 ?今天要介绍的双缓冲队列就是个不错的选择。

双缓冲队列就是冲着同步/互斥的开销来的。我们知道，在多个线程并发访问同一个资源的时候，需要特别注意线程的同步问题。稍稍不注意，噢货，程序结果不正确了。

原理

直接上图：

这样为什么会减少锁的调用呢?

举个例子，

两个List，一个用来存，一个用来取。有点迷糊？就是有一个listP从工厂那里得到玩具对象，另外一个listT就专门把它得到的玩具对象送去给Kid类处理。当listT变成空的了以后，再将listP中在这段时间内取到的所有玩具对象放到listT中，好，这完了之后，他们两个就又各自干各自的去了:listP再去取，listT再去送。这样是不是就减少了很多次的线程同步呢？至少，在它们交换之前，listP是完全被工厂类线程占有，listT是完全被Kid类线程占有的，不用处理同步。只有在listT放完了，没得给了，再去跟ListP换过来，这个时候就要处理同步了。(对比一下，原先是工厂生产一个加把锁，往队列里塞一个。消费者加一把锁，从队列里取一个。双队列可以一下取很多，是不是节约了资源呢)

阻塞队列相较于原始的生产者消费者也可以提高效率，下一篇再进行分析

转一个别人的实现

二、生产者消费者-双缓冲

一个公共缓存区，由于多线程访问的锁冲突较大，可以采取双缓冲手段来解决锁的冲突

双缓冲的关键：双缓冲队列的数据交换

1）生产者线程不断的向生产者队列A写入数据，当队列中有数据时，进行数据的交换，交换开始启动时通过条件变量通知交换线程来处理最先的数据交换。

2）数据交换完成后，通过条件变量通知消费者处理数据，此时交换线程阻塞到消费者数据处理完成时通知的条件变量上。

3）消费者收到数据交换后的通知后，进行数据的处理，数据处理完成后，通知交换线程进行下一轮的双缓冲区的数据交换。

要点：

生产者除了在数据交换时，其余时刻都在不停的生产数据。

数据交换队列需要等待消费者处理数据完成的通知，以进行下一轮交换。

消费者处理数据时，不进行数据交换，生产者同时会不断的生产数据，消费者需要等待数据交换完成的通知，并且发送消费完成的通知给交换线程

 使用条件变量的版本实现

  1 typedef struct Mutex_Condition{
  2     std::mutex mt;
  3     std::condition_variable cv;
  4 }Mutex_Condition;
  5 
  6 class Produce_1 {
  7 public:
  8     Produce_1(std::queue<int> * que_1, std::queue<int> * que_2, Mutex_Condition * mc_1 , Mutex_Condition * mc_2) {
  9         m_read_que   = que_1;
 10         m_writer_que = que_2;
 11         m_read_mc    = mc_1;
 12         m_writer_mc  = mc_2;
 13         m_stop       = false;
 14 
 15     }
 16     void runProduce() {
 17         while (!m_stop) {
 18             std::this_thread::sleep_for(std::chrono::microseconds(20 * 1000));
 19             std::lock_guard<std::mutex> lgd(m_writer_mc->mt);
 20             m_writer_que->push(1);
 21             m_writer_mc->cv.notify_one();
 22             std::cout << "m_writer push" << std::endl;
 23         }
 24         
 25     }
 26     void join() {
 27         m_trd->join();
 28         m_trd.reset();
 29     }
 30     void start() {
 31         m_trd.reset(new std::thread(std::bind(std::mem_fun(&Produce_1::runProduce), this)));
 32     }
 33     void stop() {
 34         m_stop = true;
 35     }
 36 private:
 37     Mutex_Condition * m_read_mc;
 38     Mutex_Condition * m_writer_mc;
 39     std::queue<int> * m_read_que;
 40     std::queue<int> * m_writer_que;
 41     volatile bool m_stop;
 42     std::shared_ptr<std::thread> m_trd;
 43 };
 44 
 45 
 46 class Consume_1 {
 47 public:
 48     Consume_1(std::queue<int> * que_1, std::queue<int> * que_2, Mutex_Condition * mc_1,Mutex_Condition * mc_2,Mutex_Condition * switch_mc) {
 49         m_read_que    = que_1;
 50         m_writer_que  = que_2;
 51         m_read_mc     = mc_1;
 52         m_writer_mc   = mc_2;
 53         m_stop        = false;
 54         m_switch_mc = switch_mc;
 55     }
 56 
 57     void runConsume() {
 58         while (!m_stop) {
 59             while (true) {
 60                 std::unique_lock<std::mutex> ulg(m_read_mc->mt);
 61                 while (m_read_que->empty()) {
 62                     m_read_mc->cv.wait(ulg);
 63                 }
 64                 //deal data
 65                 //std::lock_guard<std::mutex> ulg(m_read_mc->mt);
 66                 while (!m_read_que->empty()) {
 67                     m_read_que->pop();
 68                     std::cout << "m_read_queue pop" << std::endl;
 69                 }
 70                 m_switch_mc->cv.notify_one();
 71             }
 72         }
 73     }
 74     void join() {
 75         m_trd->join();
 76         m_trd.reset();
 77     }
 78     void start() {
 79         m_trd.reset(new std::thread(std::bind(std::mem_fun(&Consume_1::runConsume), this)));
 80     }
 81     void stop() {
 82         m_stop = true;
 83     }
 84 private:
 85     Mutex_Condition * m_read_mc;
 86     Mutex_Condition * m_writer_mc;
 87     Mutex_Condition * m_switch_mc;
 88     std::queue<int> * m_read_que;
 89     std::queue<int> * m_writer_que;
 90     volatile bool m_stop;
 91     std::shared_ptr<std::thread> m_trd;
 92 };
 93 void que_switch_trd(std::queue<int> * read_que, std::queue<int> * writer_que, Mutex_Condition * read_mc, Mutex_Condition * writer_mc,Mutex_Condition * switch_mc) {
 94     while (true) {
 95         {
 96             std::unique_lock<std::mutex> ulg(writer_mc->mt);
 97             while (writer_que->empty()) {
 98                 writer_mc->cv.wait(ulg);
 99             }
100             std::lock_guard<std::mutex> ulg_2(read_mc->mt);
101             std::swap(*read_que, *writer_que);
102             std::cout << "switch queue" << std::endl;
103             if (!read_que->empty()) {
104                 read_mc->cv.notify_one();
105             }
106         }
107         std::unique_lock<std::mutex> ulg_2(switch_mc->mt);
108         while (!read_que->empty()) {
109             switch_mc->cv.wait(ulg_2);
110         }
111     }
112 }
113 int main(){
114 
115     Mutex_Condition mc_1;
116     Mutex_Condition mc_2;
117     Mutex_Condition mc_3;
118     std::queue<int> que_1;
119     std::queue<int> que_2;
120 
121     Produce_1 produce_1(&que_1, &que_2, &mc_1, &mc_2);
122     Consume_1 consume_1(&que_1, &que_2, &mc_1, &mc_2,&mc_3);
123 
124     std::thread trd(std::bind(&que_switch_trd, &que_1, &que_2, &mc_1, &mc_2,&mc_3));
125     produce_1.start();
126     consume_1.start();
127     
128     produce_1.join();
129     consume_1.join();
130     trd.join();
131 
132     return 0;
133 }