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(1));
            std::lock_guard<std::mutex> lgd(*m_mt);
            m_que->push(1);
            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(1));
            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(1));
            produce(1);
            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 = 0;
            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(1));
            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(20 * 1000));
            std::lock_guard<std::mutex> lgd(m_writer_mc->mt);
            m_writer_que->push(1);
            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 0;
}

 

 

 

使用互斥锁的实现

#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(20*1000));
        que->push(1);
    }
}
void consume(DBQueue * que) {
    std::queue<int> read_que;
    while (true) {
        std::this_thread::sleep_for(std::chrono::microseconds(20*1000));
        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 0;
}

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