C++并发编程-6.利用条件变量实现线程安全队列-优快云博客

本文链接：https://blog.youkuaiyun.com/yang_pi_pi/article/details/149002804

简介

本文介绍如何使用条件变量控制并发的同步操作，试想有一个线程A一直输出1，另一个线程B一直输出2。我想让两个线程交替输出1，2，1，2…之类的效果，该如何实现？有的同学可能会说不是有互斥量mutex吗？可以用一个全局变量num表示应该哪个线程输出，比如num为1则线程A输出1，num为2则线程B输出2，mutex控制两个线程访问num，如果num和线程不匹配，就让该线程睡一会，这不就实现了吗？比如线程A加锁后发现当前num为2则表示它不能输出1，就解锁，将锁的使用权交给线程A，线程B就sleep一会。

不良编程

#include<iostream>
#include<algorithm>
#include<mutex>
#include<thread>
using std::cout;
using std::endl;


int num = 1;
std::mutex mtx_num;
void PoorImpleman()
{
    std::thread t1([]() {
        for (;;)
        {
            {
                std::lock_guard<std::mutex> lock(mtx_num);
                if (num == 1)
                {
                    cout << "Thread A print 1" << endl;
                    num++;
                }
            }

            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        });

    std::thread t2([]() {
        for (;;)
        {
            {
                std::lock_guard<std::mutex> lock(mtx_num);
                if (num == 2)
                {
                    cout << "Thread B print 1" << endl;
                    num--;
                }
            }

            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        });

    t1.join();
    t2.join();
}

int main()
{
    PoorImpleman();
    return 0;
}

PoorImpleman虽然能实现我们交替打印的功能，会造成消息处理的不及时，因为线程A要循环检测num值，如果num不为1，则线程A就睡眠了，在线程A睡眠这段时间很可能B已经处理完打印了，此时A还在睡眠，是对资源的浪费，也错过了最佳的处理时机。所以我们提出了用条件变量来通知线程的机制，当线程A发现条件不满足时可以挂起，等待线程B通知，线程B通知A后，A被唤醒继续处理。

条件变量


#include<iostream>
#include<algorithm>
#include<mutex>
#include<thread>
#include<condition_variable>
using std::cout;
using std::endl;


int num = 1;
std::mutex mtx_num;
std::condition_variable cvA, cvB;
void ResonableImplemention()
{
    std::thread t1([]() {
        for (;;)
        {
            std::unique_lock<std::mutex> lock(mtx_num);
            cvA.wait(lock, []() {
                return num == 1;
                });
            num++;
            cout << "thread A " << endl;
            cvB.notify_one();
        }
        });

    std::thread t2([]() {
        for (;;)
        {
            std::unique_lock<std::mutex> lock(mtx_num);
            cvB.wait(lock, []() {
                return num == 2;
                });
            num--;
            cout << "thread B " << endl;
            cvA.notify_one();
        }
        });
    t1.join();
    t2.join();
}
int main()
{
    ResonableImplemention();
    return 0;
}

当条件不满足时(num 不等于1 时)cvA.wait就会挂起，等待线程B通知通知线程A唤醒，线程B采用的是cvA.notifyone。
这么做的好处就是线程交替处理非常及时。比起sleep的方式，我们可以从控制台上看出差异效果，sleep的方式看出日志基本是每隔1秒才打印一次，效率不高。

线程安全队列

之前我们实现过线程安全的栈，对于pop操作，我们如果在线程中调用empty判断是否为空，如果不为空，则pop，因为empty和pop内部分别加锁，是两个原子操作，导致pop时可能会因为其他线程提前pop导致队列为空，从而引发崩溃。我们当时的处理方式是实现了两个版本的pop，一种是返回智能指针类型，一种通过参数为引用的方式返回。对于智能指针版本我们发现队列为空则返回空指针，对于引用版本，
我们可以启动三个线程，一个producer线程用来向队列中放入数据。一个consumer1线程用来阻塞等待pop队列中的元素。另一个consumer2尝试从队列中pop元素，如果队列为空则直接返回，如果非空则pop元素。打印时为了保证线程输出在屏幕上不会乱掉，所以加了锁保证互斥输出

#include <queue>
#include <memory>
#include <mutex>
#include <condition_variable>
template<typename T>
class threadsafe_queue
{
private:
    mutable std::mutex mut;
    std::queue<T> data_queue;
    std::condition_variable data_cond;
public:
    threadsafe_queue()
    {}
    threadsafe_queue(threadsafe_queue const& other)
    {
        std::lock_guard<std::mutex> lk(other.mut);
        data_queue = other.data_queue;
    }
    void push(T new_value)
    {
        std::lock_guard<std::mutex> lk(mut);
        data_queue.push(new_value);
        data_cond.notify_one();
    }
    void wait_and_pop(T& value)
    {
        std::unique_lock<std::mutex> lk(mut);
        data_cond.wait(lk, [this] {return !data_queue.empty(); });
        value = data_queue.front();
        data_queue.pop();
    }

    std::shared_ptr<T> wait_and_pop()
    {
        std::unique_lock<std::mutex> lk(mut);
        data_cond.wait(lk, [this] {return !data_queue.empty(); });
        std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
        data_queue.pop();
        return res;
    }
    bool try_pop(T& value)
    {
        std::lock_guard<std::mutex> lk(mut);
        if (data_queue.empty())
            return false;
        value = data_queue.front();
        data_queue.pop();
        return true;
    }
    std::shared_ptr<T> try_pop()
    {
        std::lock_guard<std::mutex> lk(mut);
        if (data_queue.empty())
            return std::shared_ptr<T>();
        std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
        data_queue.pop();
        return res;
    }
    bool empty() const
    {
        std::lock_guard<std::mutex> lk(mut);
        return data_queue.empty();
    }
};

void test_safe_que() {
    threadsafe_queue<int>  safe_que;
    std::mutex  mtx_print;
    std::thread producer(
        [&]() {
            for (int i = 0; ; i++) {
                safe_que.push(i);
                {
                    std::lock_guard<std::mutex> printlk(mtx_print);
                    std::cout << "producer push data is " << i << std::endl;
                }

                std::this_thread::sleep_for(std::chrono::milliseconds(200));
            }
        }
    );

    std::thread consumer1(
        [&]() {
            for (;;) {
                auto data = safe_que.wait_and_pop();
                {
                    std::lock_guard<std::mutex> printlk(mtx_print);
                    std::cout << "consumer1 wait and pop data is " << *data << std::endl;
                }

                std::this_thread::sleep_for(std::chrono::milliseconds(500));
            }
        }
    );

    std::thread consumer2(
        [&]() {
            for (;;) {
                auto data = safe_que.try_pop();
                if (data != nullptr) {
                    {
                        std::lock_guard<std::mutex> printlk(mtx_print);
                        std::cout << "consumer2 try_pop data is " << *data << std::endl;
                    }

                }

                std::this_thread::sleep_for(std::chrono::milliseconds(500));
            }
        }
    );

    producer.join();
    consumer1.join();
    consumer2.join();
}