Bir iş parçacığının işlemeyi tamamlamasını beklemek için bir destek koşulu değişkenini nasıl kullanırım?

Question

Başka bir iş parçacığı işlenmeyi tamamlayana kadar bir iş parçacığı durdurmak için koşullu bir değişken kullanıyorum görev sırası (uzun hikaye). Yani, bir iş parçacığı üzerinde ben kilitlemek ve bekle şu şekildedir:

boost::mutex::scoped_lock lock(m_mutex); 
m_condition.wait(lock); 

diğer iplik 's görevleri tamamlandıktan sonra, bekleyen iş parçacığı işaret:

boost::mutex::scoped_lock lock(m_parent.m_mutex); 
m_parent.m_condition.notify_one(); 

görüyorum sorun bekleyen olmasıdır Aşağıdaki yönergeleri bir kesme noktası ayarlamadık sürece iş parçacığı beklemez (Ben xcode, fyi kullanıyorum). Evet, bu garip görünüyor. Bunun neden olabileceğini bilen var mı? Koşul değişkenini yanlış mı kullanıyorum?

Answer 1

Evet, koşul değişkenini yanlış kullanıyorsunuz. "Koşul değişkenleri" gerçekten sadece sinyal mekanizmasıdır. Ayrıca bir koşulu test etmelisiniz. Durumunuzda, notify_one() çağıran iş parçacığının, wait() numaralı çağrıları başlatan iş parçacığı başlamadan gerçekten tamamlanmış olması durumu olabilir. (Ya da en azından wait() çağrısından önce notify_one() çağrısı gerçekleşir.) Buna "cevapsız uyandırma" denir.

çözüm aslında umurumda koşulu içeren bir değişken sahip olmaktır: diğer iplik o zaman bile bekleyen başlamadan önce worker_is_done==true sadece düşeceğiz Eğer

bool worker_is_done=false; 

boost::mutex::scoped_lock lock(m_mutex); 
while (!worker_is_done) m_condition.wait(lock); 

ve

boost::mutex::scoped_lock lock(m_mutex); 
worker_is_done = true; 
m_condition.notify_one(); 

Süre boyunca hiçbir zaman wait() numaralı telefonu aramadan.

Bu desen o kadar yaygındır ki, condition_variable.wait()'unuzu sarmak için bir while döngüsüne sahip değilseniz, her zaman bir hata vardır. Aslında, ne zaman C++ 11 boost benzer bir şey kabul :: Bir yüklem lambda ifadesi alır) onlar bekle (yeni bir tür eklendi condtion_variable (aslında bu sizin için while döngü yapar):

std::condition_variable cv; 
std::mutex m; 
bool worker_is_done=false; 


std::unique_lock<std::mutex> lk(m); 
cv.wait(lk, []{return worker_is_done;}); 

Answer 2

Tartışmaya dayanarak destek koşulunun nasıl kullanılacağını gösteren bir örnek uygulamıştım.

#include <iostream> 

#include <boost/asio.hpp> 
#include <boost/thread/mutex.hpp> 
#include <boost/thread/thread.hpp> 

boost::mutex io_mutex; 
bool worker_is_done = false; 
boost::condition_variable condition; 

void workFunction() 
{ 
    std::cout << "Waiting a little..." << std::endl; 
    boost::this_thread::sleep(boost::posix_time::seconds(1)); 
    worker_is_done = true; 
    std::cout << "Notifying condition..." << std::endl; 
    condition.notify_one(); 
    std::cout << "Waiting a little more..." << std::endl; 
    boost::this_thread::sleep(boost::posix_time::seconds(1)); 
} 

int main() 
{ 
    boost::mutex::scoped_lock lock(io_mutex); 
    boost::thread workThread(&workFunction); 

    while (!worker_is_done) condition.wait(lock); 
    std::cout << "Condition notified." << std::endl; 
    workThread.join(); 
    std::cout << "Thread finished." << std::endl; 

    return 0; 
} 

Boost condition variable example