C++11 实现生产者消费者双缓冲

基础的生产者消费者模型，生产者向公共缓存区写入数据，消费者从公共缓存区读取数据进行处理，两个线程访问公共资源，加锁实现数据的一致性。

通过加锁来实现

 class Produce_1 {
 public:
     Produce_1(std::queue<int> * que_, std::mutex * mt_) {
         m_mt = mt_;
         m_que = que_;
         m_stop = false;
     }
     void runProduce() {
         while (!m_stop) {
             std::this_thread::sleep_for(std::chrono::seconds());
             std::lock_guard<std::mutex> lgd(*m_mt);
             m_que->push();
             std::cout << "Produce_1 produce 1" << std::endl;
         }
     }
     void join() {
         m_trd->join();
         m_trd.reset();
     }
     void start() {
         m_trd.reset(new std::thread(std::bind(std::mem_fun(&Produce_1::runProduce), this)));
     }
     void stop() {
         m_stop = true;
     }
 private:
     std::mutex * m_mt;
     std::queue<int> * m_que;
     volatile bool m_stop;
     std::shared_ptr<std::thread> m_trd;
 };

 /*
 *单缓冲一个同步队列 效率较低
 */
 class Consume_1 {
 public:
     Consume_1(std::queue<int> * que_, std::mutex * mt_) {
         m_mt = mt_;
         m_que = que_;
         m_stop = false;
     }

     void runConsume() {
         while (!m_stop) {
             std::this_thread::sleep_for(std::chrono::seconds());
             std::lock_guard<std::mutex> lgd(*m_mt);
             if (!m_que->empty()) {
                 m_que->pop();
             }
             std::cout << "Consume_1 consume" << std::endl;
         }
     }
     void join() {
         m_trd->join();
         m_trd.reset();
     }
     void start() {
         m_trd.reset(new std::thread(std::bind(std::mem_fun(&Consume_1::runConsume), this)));
     }
     void stop() {
         m_stop = true;
     }
 private:
     std::mutex * m_mt;
     std::queue<int> * m_que;
     volatile bool m_stop;
     std::shared_ptr<std::thread> m_trd;
 };

通过条件变量来实现

 typedef struct Mutex_Condition{
     std::mutex mt;
     std::condition_variable cv;
 }Mutex_Condition;

 class Produce {
 public:
     Produce(std::queue<int> * que_, Mutex_Condition * mc_) {
         m_que = que_;
         m_mc = mc_;
         m_stop = false;
     }
     void join() {
         m_trd->join();
         m_trd.reset();
     }
     void produce(int enter) {
         std::lock_guard<std::mutex> lgd(m_mc->mt);
         m_que->push(enter);
         m_mc->cv.notify_one();
     }

     void runProduce() {
         while (!m_stop) {
             std::this_thread::sleep_for(std::chrono::seconds());
             produce();
             std::cout << "Produce Thread produce 1 " << std::endl;
         }
     }

     void start() {
         m_trd.reset(new std::thread(std::bind(std::mem_fun(&Produce::runProduce), this)));
     }
     void stop() {
         m_stop = true;
     }

 private:
     std::queue<int> * m_que;
     Mutex_Condition * m_mc;
     std::shared_ptr<std::thread> m_trd;
     volatile bool m_stop;
 };

 class Consume {
 public:
     Consume(std::queue<int> * que_, Mutex_Condition * mc_) {
         m_que = que_;
         m_mc = mc_;
         m_stop = false;
     }
     void join() {
         m_trd->join();
         m_trd.reset();
     }
     void consume() {
         std::unique_lock<std::mutex> lgd(m_mc->mt);
         while (m_que->empty()) {
             int i = ;
             m_mc->cv.wait(lgd);
         }
         m_que->pop();
         std::cout << "Consume Thread consume " << std::endl;
     }
     void runConsume() {
         while (!m_stop) {
             std::this_thread::sleep_for(std::chrono::seconds());
             consume();
         }
     }
     void start() {
         m_trd.reset(new std::thread(std::bind(std::mem_fun(&Consume::runConsume), this)));
     }
     void stop() {
         m_stop = true;
     }

 private:
     std::queue<int> * m_que;
     Mutex_Condition * m_mc;
     std::shared_ptr<std::thread> m_trd;
     volatile bool m_stop;

 };

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

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

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

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

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

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

要点：

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

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

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

 使用条件变量的版本实现

 typedef struct Mutex_Condition{
     std::mutex mt;
     std::condition_variable cv;
 }Mutex_Condition;

 class Produce_1 {
 public:
     Produce_1(std::queue<int> * que_1, std::queue<int> * que_2, Mutex_Condition * mc_1 , Mutex_Condition * mc_2) {
         m_read_que   = que_1;
         m_writer_que = que_2;
         m_read_mc    = mc_1;
         m_writer_mc  = mc_2;
         m_stop       = false;

     }
     void runProduce() {
         while (!m_stop) {
             std::this_thread::sleep_for(std::chrono::microseconds( * ));
             std::lock_guard<std::mutex> lgd(m_writer_mc->mt);
             m_writer_que->push();
             m_writer_mc->cv.notify_one();
             std::cout << "m_writer push" << std::endl;
         }

     }
     void join() {
         m_trd->join();
         m_trd.reset();
     }
     void start() {
         m_trd.reset(new std::thread(std::bind(std::mem_fun(&Produce_1::runProduce), this)));
     }
     void stop() {
         m_stop = true;
     }
 private:
     Mutex_Condition * m_read_mc;
     Mutex_Condition * m_writer_mc;
     std::queue<int> * m_read_que;
     std::queue<int> * m_writer_que;
     volatile bool m_stop;
     std::shared_ptr<std::thread> m_trd;
 };

 class Consume_1 {
 public:
     Consume_1(std::queue<int> * que_1, std::queue<int> * que_2, Mutex_Condition * mc_1,Mutex_Condition * mc_2,Mutex_Condition * switch_mc) {
         m_read_que    = que_1;
         m_writer_que  = que_2;
         m_read_mc     = mc_1;
         m_writer_mc   = mc_2;
         m_stop        = false;
         m_switch_mc = switch_mc;
     }

     void runConsume() {
         while (!m_stop) {
             while (true) {
                 std::unique_lock<std::mutex> ulg(m_read_mc->mt);
                 while (m_read_que->empty()) {
                     m_read_mc->cv.wait(ulg);
                 }
                 //deal data
                 //std::lock_guard<std::mutex> ulg(m_read_mc->mt);
                 while (!m_read_que->empty()) {
                     m_read_que->pop();
                     std::cout << "m_read_queue pop" << std::endl;
                 }
                 m_switch_mc->cv.notify_one();
             }
         }
     }
     void join() {
         m_trd->join();
         m_trd.reset();
     }
     void start() {
         m_trd.reset(new std::thread(std::bind(std::mem_fun(&Consume_1::runConsume), this)));
     }
     void stop() {
         m_stop = true;
     }
 private:
     Mutex_Condition * m_read_mc;
     Mutex_Condition * m_writer_mc;
     Mutex_Condition * m_switch_mc;
     std::queue<int> * m_read_que;
     std::queue<int> * m_writer_que;
     volatile bool m_stop;
     std::shared_ptr<std::thread> m_trd;
 };
 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) {
     while (true) {
         {
             std::unique_lock<std::mutex> ulg(writer_mc->mt);
             while (writer_que->empty()) {
                 writer_mc->cv.wait(ulg);
             }
             std::lock_guard<std::mutex> ulg_2(read_mc->mt);
             std::swap(*read_que, *writer_que);
             std::cout << "switch queue" << std::endl;
             if (!read_que->empty()) {
                 read_mc->cv.notify_one();
             }
         }
         std::unique_lock<std::mutex> ulg_2(switch_mc->mt);
         while (!read_que->empty()) {
             switch_mc->cv.wait(ulg_2);
         }
     }
 }
 int main(){

     Mutex_Condition mc_1;
     Mutex_Condition mc_2;
     Mutex_Condition mc_3;
     std::queue<int> que_1;
     std::queue<int> que_2;

     Produce_1 produce_1(&que_1, &que_2, &mc_1, &mc_2);
     Consume_1 consume_1(&que_1, &que_2, &mc_1, &mc_2,&mc_3);

     std::thread trd(std::bind(&que_switch_trd, &que_1, &que_2, &mc_1, &mc_2,&mc_3));
     produce_1.start();
     consume_1.start();

     produce_1.join();
     consume_1.join();
     trd.join();

     return ;
 }

使用互斥锁的实现

 #include<mutex>
 #include<thread>
 #include<queue>
 #include<iostream>
 #include<chrono>

 class DBQueue{
 public:
     void push(int i_) {
         std::lock_guard<std::mutex> lock(m_mt);
         std::cout << "write_que push " << i_ << std::endl;
         m_write_que.push(i_);
     }
     void swap(std::queue<int> & read_que) {
         std::lock_guard<std::mutex> lock(m_mt);
         std::swap(m_write_que,read_que);
         std::cout << "switch swap" << std::endl;
     }
 private:
     std::queue<int> m_write_que;
     std::mutex m_mt;
 };
 void produce(DBQueue * que) {
     while (true) {
         std::this_thread::sleep_for(std::chrono::microseconds(*));
         que->push();
     }
 }
 void consume(DBQueue * que) {
     std::queue<int> read_que;
     while (true) {
         std::this_thread::sleep_for(std::chrono::microseconds(*));
         if (read_que.empty()) {
             que->swap(read_que);
             //xxoo
             while (!read_que.empty()) {
                 std::cout << "read_que pop" << std::endl;
                 read_que.pop();
             }
         }
     }
 }
 int main()
 {
     DBQueue que;
     std::thread trd_1(std::bind(&produce, &que));
     std::thread trd_2(std::bind(&consume, &que));
     trd_1.join();
     trd_2.join();
     return ;
 }

 两个版本的区别 sleep的区别，sleep处理的时效性较差，不加sleep，cpu占用率又比较高，所以条件变量是比较好的选择。