C++でのマルチスレッドキューの破棄

Question

共有の並行キューがあります。それは破壊を除いてうまくいっているようです。

キューの実装方法は、条件変数とミューテックスのペアが含まれていることです。 この条件変数で待機するいくつかのワーカースレッドが起動します。新しいオブジェクトが作業できるようになると、それらはキューにプッシュされ、条件変数が通知されます。

問題は、メインスレッドが終了してキューが破棄されると、条件変数が破棄されますが、条件変数が使用されている場合は失敗します。これは例外をスローし、すべてが激しく爆発する。

私は労働者に合図して目を覚まして終了させ、それらが完了するのを待ってからメインスレッドを続けます。これらのスレッドが完了したら、私の問題は解決しています - 私は余分な同期プリミティブが必要ですか？

とにかくキューのコードHERESに：

// Based on code from http://www.justsoftwaresolutions.co.uk/threading/implementing-a-thread-safe-queue-using-condition-variables.html 
// Original version by Anthony Williams 
// Modifications by Michael Anderson 

#include "boost/thread.hpp" 
#include <deque> 

template<typename Data> 
class concurrent_queue 
{ 
private: 
    std::deque<Data> the_queue; 
    mutable boost::mutex the_mutex; 
    boost::condition_variable the_condition_variable; 
    bool is_canceled; 

public: 
    concurrent_queue() : the_queue(), the_mutex(), the_condition_variable(), is_canceled(false) {} 
    struct Canceled{}; 
    void push(Data const& data) 
    { 
     boost::mutex::scoped_lock lock(the_mutex); 
     if (is_canceled) throw Canceled(); 
     the_queue.push_back(data); 
     lock.unlock(); 
     the_condition_variable.notify_one(); 
    } 

    bool empty() const 
    { 
     boost::mutex::scoped_lock lock(the_mutex); 
     if (is_canceled) throw Canceled(); 
     return the_queue.empty(); 
    } 

    bool try_pop(Data& popped_value) 
    { 
     boost::mutex::scoped_lock lock(the_mutex); 
     if (is_canceled) throw Canceled(); 
     if(the_queue.empty()) 
     { 
      return false; 
     } 

     popped_value=the_queue.front(); 
     the_queue.pop_front(); 
     return true; 
    } 

    void wait_and_pop(Data& popped_value) 
    { 
     boost::mutex::scoped_lock lock(the_mutex); 

     while(the_queue.empty() && !is_canceled) 
     { 
      the_condition_variable.wait(lock); 
     } 
     if (is_canceled) throw Canceled(); 

     popped_value=the_queue.front(); 
     the_queue.pop_front(); 
    } 

    std::deque<Data> wait_and_take_all() 
    { 
     boost::mutex::scoped_lock lock(the_mutex); 

     while(the_queue.empty() && !is_canceled) 
     { 
      the_condition_variable.wait(lock); 
     } 
     if (is_canceled) throw Canceled(); 

     std::deque<Data> retval; 
     std::swap(retval, the_queue); 
     return retval; 
    } 

    void cancel() 
    { 
     boost::mutex::scoped_lock lock(the_mutex); 
     if (is_canceled) throw Canceled(); 
     is_canceled = true; 
     lock.unlock(); 
     the_condition_variable.notify_all(); 
    } 

}; 

Answer 1

あなたはそれが実行を完了するまで待機する各スレッドにjoin()を呼び出すことができます。このような何か：

void DoWork() {}; 

int main() 
{ 
    boost::thread t(&DoWork); 
    // signal for the thread to exit 
    t.join(); // wait until it actually does exit 

    // destroy the queue 
} 

それとも、複数のスレッドのためboost::thread_groupを使用することができます。

int main() 
{ 
    boost::thread_group tg; 

    for(int i = 0 ; i < 10 ; ++i) 
     tg.create_thread(&DoWork); 

    // signal to stop work 

    tg.join_all(); 

    // destroy the queue 
} 

Answer 2

2つのオプションがあります。キューが有効範囲外になったときに、他のスレッドがそれを参照している間に実際には破棄されません（つまりshared_ptrを使用して他のスレッドに渡し、main（）の最後でcancel（）を呼び出します; throwキャンセルされ、おそらく終了すると、キューは破棄されます）。

また、実際にmain（）の最後まで確実に破棄されるようにするには、他のスレッドを待つ必要があります。あなたがデストラクタの外で待機を処理することでOKなら、JaredCが示唆していることを行うことができます。デストラクタの内部でそれを行うには、すべてのスレッドを格納するのではなく、単にカウントと別の同期プリミティブを保持する方がクリーンであるようです。いずれにしても、すべてのスレッドが終了するのを待つためにキューを必要とします。

私にとっては、（shared_ptrの）最初の解決策がより洗練されているようです。