thread.join（）のタイムアウト

Question

std::thread::join()へのコールにタイムアウトを設定することはできますか？私は、スレッドが実行に時間がかかりすぎる場合や、スレッドを終了する場合を処理したい。私はこれを複数のスレッド（たとえば、最大30）に対して実行している可能性があります。

ブーストなしで行うことをお勧めしますが、これが最善の方法であれば、私はブーストソリューションに興味があります。

Answer 1

std::thread::join()のタイムアウトはありません。しかし、std::thread::join()は単に便利な機能として見ることができます。 condition_variableを使用すると、スレッド間の非常に豊富なコミュニケーションと協力関係を作成できます。例：この例では

#include <chrono> 
#include <thread> 
#include <iostream> 

int thread_count = 0; 
bool time_to_quit = false; 
std::mutex m; 
std::condition_variable cv; 

void f(int id) 
{ 
    { 
    std::lock_guard<std::mutex> _(m); 
    ++thread_count; 
    } 
    while (true) 
    { 
     { 
     std::lock_guard<std::mutex> _(m); 
     std::cout << "thread " << id << " working\n"; 
     } 
     std::this_thread::sleep_for(std::chrono::milliseconds(250)); 
     std::lock_guard<std::mutex> _(m); 
     if (time_to_quit) 
      break; 
    } 
    std::lock_guard<std::mutex> _(m); 
    std::cout << "thread ended\n"; 
    --thread_count; 
    cv.notify_all(); 
} 

int main() 
{ 
    typedef std::chrono::steady_clock Clock; 
    std::thread(f, 1).detach(); 
    std::thread(f, 2).detach(); 
    std::thread(f, 3).detach(); 
    std::thread(f, 4).detach(); 
    std::thread(f, 5).detach(); 
    auto t0 = Clock::now(); 
    auto t1 = t0 + std::chrono::seconds(5); 
    std::unique_lock<std::mutex> lk(m); 
    while (!time_to_quit && Clock::now() < t1) 
     cv.wait_until(lk, t1); 
    time_to_quit = true; 
    std::cout << "main ending\n"; 
    while (thread_count > 0) 
     cv.wait(lk); 
    std::cout << "main ended\n"; 
} 

mainは、ミューテックス（これはまた、原子することができる）の下で終了する時間であれば、時折チェックすべてが、仕事をするために複数のスレッドを起動します。また、メインスレッドは終了するかどうかを監視します（スレッドがすべての作業を完了した場合）。メインが忍耐を使い果たすと、彼は終了すると宣言し、終了する前にすべてのスレッドが必要なクリーンアップを実行するのを待ちます。

Answer 2

ブーストの場合、join（）のタイムアウトのバージョンはtimed_join（）を参照してください。

Answer 3

timed_join（）は廃止予定です。代わりに）（try_join_forを使用します。

myThread.try_join_for(boost::chrono::milliseconds(8000)) 

Answer 4

代わりに明示的にstd::future<>を提供するためにstd::async()を使用することができますし、std::futureに、時限待機を行うことができますスレッドを使用しての：

http://en.cppreference.com/w/cpp/thread/future/wait_for

Answer 5

はい、それは可能だ。 Galikによって提案されたソリューションは、次のようになります。

#include <thread> 
#include <future> 
... 
// Launch the thread. 
std::thread thread(ThreadFnc, ...); 
... 
// Terminate the thread. 
auto future = std::async(std::launch::async, &std::thread::join, &thread); 
if (future.wait_for(std::chrono::seconds(5)) 
    == std::future_status::timeout) { 

    /* --- Do something, if thread has not terminated within 5 s. --- */ 

} 

しかし、これは本質的thread.join()を行い、第三のスレッドを起動します。

（注：threadが参加していると、補助スレッドが終了するまでfutureのデストラクタがブロックされます）

---

は多分ちょうど別のスレッドをダウンさせるためにスレッドを起動するには、あなたが望むものではありません。 T_returnあなたのスレッド手続きの戻り値の型である

#include <thread> 
#include <future> 
... 
// Launch the thread. 
std::future<T_return>* hThread 
    = new std::future<T_return>(std::async(std::launch::async, ThreadFnc, ...)); 
... 
// Terminate the thread. 
if (hThread->wait_for(std::chrono::seconds(5)) 
    == std::future_status::timeout) { 

    /* --- Do something, if thread has not terminated within 5 s. --- */ 

} else 
    delete hThread; 

：補助スレッドのない別の、ポータブルソリューションがあります。このシナリオでは、std::threadの代わりにstd::future/std::asyncの組み合わせが使用されます。

hThreadはポインタです。 delete演算子を呼び出すと、デストラクタが*hThreadとなり、スレッドが終了するまでブロックされます。

私は両方のバージョンをgg 4.9.3でCygwinでテストしました。