C++多線程條件變量

C++多線程中的條件變量的使用。

在多線程編程中，常常使用條件變量來等待某個事件的發生。

先看代碼

#include <thread>
#include <mutex>
#include <condition_variable>
#include <list>
#include <string>
#include <iostream>
#include <chrono>

class Event {
public:
    enum Type : int {
        quit = 0 ,
        help = 1
    };

    explicit Event(Type type)
        : m_type(type)
    { }

    virtual ~Event()
    { }

    Type type() const { return m_type; }
private:
    Type m_type;
};

class QuitEvent
        : public Event
{
public:
    explicit QuitEvent(int exitCode = 0)
        : Event(quit)
        , m_exitCode(exitCode)
    { }

    void setExitCode(int exitCode) { m_exitCode = exitCode; }
    int exitCode() const { return m_exitCode; }

private:
    int m_exitCode;
};

class HelpEvent
    : public Event
{
public:
    explicit HelpEvent(const std::string& msg)
        : Event(help)
        , m_msg(msg)
    {}

    void setMsg(const std::string& msg) { m_msg = msg; }

    std::string msg() const { return m_msg; }

private:
    std::string m_msg;
};

class EventQueue {
public:
    Event* GetEvent()
    {
        std::unique_lock<std::mutex> locker(m_evtQueueMtx);
        while(m_eventQueue.empty())
            m_evtQueueCondVar.wait(locker);
        Event* evt = m_eventQueue.front();
        m_eventQueue.pop_front();
        return evt;
    }

    void PushEvent(Event* evt)
    {
        m_evtQueueMtx.lock();
        const bool bNeedNotify = m_eventQueue.empty();
        m_eventQueue.push_back(evt);
        m_evtQueueMtx.unlock();
        if (bNeedNotify)
            m_evtQueueCondVar.notify_all();
    }

private:
    std::mutex m_evtQueueMtx;
    std::condition_variable m_evtQueueCondVar;
    std::list<Event*> m_eventQueue;
};

void thread_proc(const std::string& name , EventQueue *queue)
{
    for(;;)
    {
        Event *evt = queue->GetEvent();
        if (evt->type() == Event::quit)
        {
            QuitEvent* e = static_cast<QuitEvent*>(evt);
            std::cout << "thread " << name << " quit. Quit code : " << e->exitCode() << std::endl;
            delete e;
            break;
        }
        else if (evt->type() == Event::help)
        {
            HelpEvent *e = static_cast<HelpEvent*>(evt);
            std::cout << "thread " << name << " get a help event. Msg : " << e->msg() << std::endl;
            delete e;
        }
        else
        {
            std::cout << "thread " << name << " get an event. Type : " << evt->type() << std::endl;
        }
    }
}

int main(int argc, char *argv[])
{
    EventQueue evtQueue;
    std::thread thread1(thread_proc , "thread1" , &evtQueue);
    std::thread thread2(thread_proc , "thread2" , &evtQueue);
    std::thread thread3(thread_proc , "thread3" , &evtQueue);
    std::thread thread4(thread_proc , "thread4" , &evtQueue);
    std::thread thread5(thread_proc , "thread5" , &evtQueue);
    std::thread thread6(thread_proc , "thread6" , &evtQueue);

    for(int i = 0; i < 1000; ++i)
    {
        if (rand() % 2 == 0)
            evtQueue.PushEvent(new Event(static_cast<Event::Type>(rand())));
        else
            evtQueue.PushEvent(new HelpEvent(std::to_string(rand() % 500) + "--help msg"));

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

    for(int i = 0; i < 6; ++i)
    {
        evtQueue.PushEvent(new QuitEvent(qrand() % 500));
    }

    thread1.join();
    thread2.join();
    thread3.join();
    thread4.join();
    thread5.join();
    thread6.join();

    std::cout << "All Quit!" << std::endl;

    return 0;
}

上述代碼中，有幾個問題需要澄清：

1.為什么66、67行代碼有一個while循環。

2.為什么條件變量的使用必須帶有一個互斥鎖。

3.為什么條件變量使用的互斥鎖和PushEvent函數使用的互斥鎖是同一個。

4.互斥鎖到底保護了什么.

問題1：

　　為了更加有效的使用條件變量，我們使用了condition_variable::notify_all 來切換條件變量的狀態。這樣所有等待的線程都有機會被喚醒。在上述例子中假如thread1先被喚醒，之后thread2被喚醒，對於thread2來說，應當再一次檢查事件列隊中是否有可用事件，因為thread1或者別的先於thread2被喚醒的線程可能已經將事件列隊清空。所以每一次線程被喚醒都應當再次檢查事件列隊是有事件可用。如果沒有事件則應該再次進入等待狀態。

問題2：

　　條件變量能夠在喚醒的同時加鎖。喚醒和加鎖是一個原子操作，這樣當線程被喚醒是就能夠立即獲得資源的額訪問權。當訪問共享資源時應當在訪問前加鎖，如果不滿足訪問條件則應該釋放鎖並且進入等待狀態，這樣別的線程才能夠訪問共享資源。如果條件變量不帶互斥鎖，則當條件變量被喚醒時，應當對共享資源加鎖。則應當寫一下的偽代碼：

forever {

　　lock

　　if (ok)

　　{

　　　　access;

　　　　unlock;

　　　　break;

　　}

　　else

　　{

　　　　unlock;

　　　　wait;

　　}

}

　　從上述代碼看出有更多的加鎖和解鎖操作。當線程進入等待時會進入內核狀態，多次的加鎖和解鎖等待會造成線程在用戶態和內核態之前頻繁切換，這會帶來性能問題，也容易使得編寫有bug的代碼。

問題3：

　　從對問題2的分析可以看出，兩個地方使用的互斥鎖是為了保護同一個資源。為了保持訪問的唯一性，因此必須是同一個互斥鎖。

問題4：

　　到此，問題4就很簡單了，互斥鎖保護的是被等待的資源。上述例子中是事件列隊。

 

by linannk

2016.06.03 01:02