Может ли несколько потоков присоединиться к одному и тому же boost :: thread?

Question

pthreads имеет неопределенное поведение, если несколько потоков пытаются присоединиться к той же нити:

Если несколько потоков одновременно пытаются присоединиться к одной и той же теме, результаты не определены.

То же самое верно для boost::thread s? В документации не указано это.

Если это не определено, то какой будет чистый путь для нескольких потоков, чтобы ждать по одному потоку?

Answer 1

Если это не определено, то какой будет чистый способ для нескольких потоков ждать на одном потоке?

Чистый способ был бы для этого потока, чтобы сообщить другим, что он завершен. A packaged_task содержит future, на который можно ждать, что может помочь нам здесь.

Вот один из способов сделать это. Я использовал std :: thread и std :: packaged_task, но вы также можете использовать эквиваленты boost.

#include <thread> 
#include <mutex> 
#include <future> 
#include <vector> 
#include <iostream> 

void emit(const char* msg) { 
    static std::mutex m; 
    std::lock_guard<std::mutex> l(m); 
    std::cout << msg << std::endl; 
    std::cout.flush(); 
} 

int main() 
{ 
    using namespace std; 

    auto one_task = std::packaged_task<void()>([]{ 
     emit("waiting..."); 
     std::this_thread::sleep_for(std::chrono::microseconds(500)); 
     emit("wait over!"); 
    }); 

    // note: convert future to a shared_future so we can pass it 
    // to two subordinate threads simultaneously 
    auto one_done = std::shared_future<void>(one_task.get_future()); 
    auto one = std::thread(std::move(one_task)); 

    std::vector<std::thread> many; 
    many.emplace_back([one_done] { 
     one_done.wait(); 
     // do my thing here 
     emit("starting thread 1"); 
    }); 

    many.emplace_back([one_done] { 
     one_done.wait(); 
     // do my thing here 
     emit("starting thread 2"); 
    }); 

    one.join(); 
    for (auto& t : many) { 
     t.join(); 
    } 

    cout << "Hello, World" << endl; 
    return 0; 
} 

ожидается выход:

waiting... 
wait over! 
starting thread 2 
starting thread 1 
Hello, World 

Answer 2

Я в конечном итоге с помощью boost::condition_variable ... примерно:

class thread_wrapper { 
    boost::mutex mutex; 
    boost::condition_variable thread_done_condition; 
    bool thread_done = false; 

    void the_func() { 
     // ... 
     // end of the thread 
     { 
      boost:unique_lock<boost::mutex> lock(mutex); 
      thread_done = true; 
     } 
     thread_done_condition.notify_all(); 
    } 

    void wait_until_done() { 
     boost::unique_lock<boost::mutex> lock(mutex); 
     thread_done_condition.wait(lock, [this]{ return thread_done; }); 
    } 
} 

Затем несколько вызывающих абонентов можно смело назвать wait_until_done().

Answer 3

Она поражает меня теперь что-то вроде бы и работали следующие:

class thread_wrapper { 
public: 
    thread_wrapper() : thread([this]() { this->the_func(); }) { } 

    void wait_until_done() { 
     boost::unique_lock<boost::mutex> lock(join_mutex); 
     thread.join(); 
    } 

private: 
    void the_func() { 
     // ... 
    } 

    boost::mutex join_mutex; 
    boost::thread thread; 
}