Использование std :: mutex, std :: condition_variable и std :: unique_lock

У меня возникли проблемы с пониманием условных переменных и их использования с мьютексами, надеюсь, сообщество поможет мне в этом. Обратите внимание, что я пришел из фона win32, поэтому я использую CRITICAL_SECTION, HANDLE, SetEvent, WaitForMultipleObject и т. Д.

Вот моя первая попытка параллелизма с использованием стандартной библиотеки c ++ 11, это модифицированная версия пример программы можно найти здесь.

#include <condition_variable>
#include <mutex>
#include <algorithm>
#include <thread>
#include <queue>
#include <chrono>
#include <iostream>int _tmain(int argc, _TCHAR* argv[])
{
std::queue<unsigned int>    nNumbers;

std::mutex                  mtxQueue;
std::condition_variable     cvQueue;
bool                        m_bQueueLocked = false;

std::mutex                  mtxQuit;
std::condition_variable     cvQuit;
bool                        m_bQuit = false;std::thread thrQuit(
[&]()
{
using namespace std;

this_thread::sleep_for(chrono::seconds(7));

// set event by setting the bool variable to true
// then notifying via the condition variable
m_bQuit = true;
cvQuit.notify_all();
}
);

std::thread thrProducer(
[&]()
{
using namespace std;

int nNum = 0;
unique_lock<mutex> lock( mtxQuit );

while( ( ! m_bQuit ) &&
( cvQuit.wait_for( lock, chrono::milliseconds(10) ) == cv_status::timeout ) )
{
nNum ++;

unique_lock<mutex> qLock(mtxQueue);
cout << "Produced: " << nNum << "\n";
nNumbers.push( nNum );
}
}
);

std::thread thrConsumer(
[&]()
{
using namespace std;

unique_lock<mutex> lock( mtxQuit );

while( ( ! m_bQuit ) &&
( cvQuit.wait_for( lock, chrono::milliseconds(10) ) == cv_status::timeout ) )
{
unique_lock<mutex> qLock(mtxQueue);
if( nNumbers.size() > 0 )
{
cout << "Consumed: " << nNumbers.front() << "\n";
nNumbers.pop();
}
}
}
);

thrQuit.join();
thrProducer.join();
thrConsumer.join();

return 0;
}

Несколько вопросов по этому поводу.

Я прочитал это msgstr «любой поток, который намерен ждать на std :: condition_variable, должен сначала получить std :: unique_lock.»

Итак, у меня есть {quit mutex, переменная условия & bool}, чтобы указать, когда о выходе было сообщено. Каждый из потоков производителей и потребителей должен получить std :: unique_lock следующим образом:

std::unique_lock<std::mutex> lock(m_mtxQuit);

Это запутывает меня до чертиков. Разве это не заблокирует выходной мьютекс в первом потоке, тем самым блокируя второй? И если это правда, то как первый поток снимает блокировку, чтобы другой поток мог начаться?

Другой вопрос: если я изменю вызов wait_for () на ожидание в течение нулевых секунд, этот поток будет голодать. Может кто-нибудь объяснить? Я ожидаю, что он не будет блокироваться перед выполнением цикла while (правильно ли я предположить, что no_timeout записывается вместо timeout?).

Как я могу вызвать wait_for () и указать нулевое время, чтобы вызов wait_for () не блокировался, а просто проверял условие и продолжал?

Мне также было бы интересно услышать о хороших ссылках на эту тему.