std :: threadがまだ実行されているかどうかを確認する方法は？

std::threadがまだ実行されているかどうかを（プラットフォームに依存しない方法で）確認するにはどうすればよいですか？それはtimed_join()方法を欠いており、そのためのものでjoinable()はありません。

std::lock_guardスレッド内のaでミューテックスをロックし、ミューテックスのtry_lock()メソッドを使用して、それがまだロックされている（スレッドが実行されている）かどうかを判断することを考えましたが、不必要に複雑に思えます。

もっとエレガントな方法を知っていますか？

更新：明確にするために：スレッドが正常に終了したかどうかを確認したいと思います。「ぶら下がっている」スレッドは、この目的で実行されていると見なされます。

C ++ 11std::asyncをstd::future使用してタスクを実行する場合は、のwait_for関数std::futureを使用して、スレッドが次のように適切に実行されているかどうかを確認できます。

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

int main() {
    using namespace std::chrono_literals;

    /* Run some task on new thread. The launch policy std::launch::async
       makes sure that the task is run asynchronously on a new thread. */
    auto future = std::async(std::launch::async, [] {
        std::this_thread::sleep_for(3s);
        return 8;
    });

    // Use wait_for() with zero milliseconds to check thread status.
    auto status = future.wait_for(0ms);

    // Print status.
    if (status == std::future_status::ready) {
        std::cout << "Thread finished" << std::endl;
    } else {
        std::cout << "Thread still running" << std::endl;
    }

    auto result = future.get(); // Get result.
}

を使用する必要がある場合はstd::thread、を使用std::promiseして将来のオブジェクトを取得できます。

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

int main() {
    using namespace std::chrono_literals;

    // Create a promise and get its future.
    std::promise<bool> p;
    auto future = p.get_future();

    // Run some task on a new thread.
    std::thread t([&p] {
        std::this_thread::sleep_for(3s);
        p.set_value(true); // Is done atomically.
    });

    // Get thread status using wait_for as before.
    auto status = future.wait_for(0ms);

    // Print status.
    if (status == std::future_status::ready) {
        std::cout << "Thread finished" << std::endl;
    } else {
        std::cout << "Thread still running" << std::endl;
    }

    t.join(); // Join thread.
}

これらの例は両方とも次のように出力されます。

Thread still running

これはもちろん、タスクが終了する前にスレッドのステータスがチェックされるためです。

しかし、繰り返しになりますが、他の人がすでに述べたように、それを行う方が簡単かもしれません。

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

int main() {
    using namespace std::chrono_literals;

    std::atomic<bool> done(false); // Use an atomic flag.

    /* Run some task on a new thread.
       Make sure to set the done flag to true when finished. */
    std::thread t([&done] {
        std::this_thread::sleep_for(3s);
        done = true;
    });

    // Print status.
    if (done) {
        std::cout << "Thread finished" << std::endl;
    } else {
        std::cout << "Thread still running" << std::endl;
    }

    t.join(); // Join thread.
}

編集：

std::packaged_taskを使用するstd::threadよりもクリーンなソリューションのために使用するためのものもありますstd::promise：

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

int main() {
    using namespace std::chrono_literals;

    // Create a packaged_task using some task and get its future.
    std::packaged_task<void()> task([] {
        std::this_thread::sleep_for(3s);
    });
    auto future = task.get_future();

    // Run task on new thread.
    std::thread t(std::move(task));

    // Get thread status using wait_for as before.
    auto status = future.wait_for(0ms);

    // Print status.
    if (status == std::future_status::ready) {
        // ...
    }

    t.join(); // Join thread.
}

簡単な解決策は、スレッドが定期的にtrueに設定し、ステータスを知りたいスレッドによってチェックされてfalseに設定されるブール変数を設定することです。変数が長い間falseの場合、スレッドはアクティブであるとは見なされなくなります。

よりスレッドセーフな方法は、子スレッドによって増加するカウンターを用意することです。メインスレッドはカウンターを保存された値と比較し、時間がかかりすぎると子スレッドはアクティブでないと見なされます。

ただし、C ++ 11には、ハングしたスレッドを実際に強制終了または削除する方法がないことに注意してください。

編集スレッドが正常に終了したかどうかを確認する方法：基本的に、最初の段落で説明したのと同じ手法。ブール変数をfalseに初期化します。子スレッドが最後に行うことは、それをtrueに設定することです。次に、メインスレッドはその変数をチェックし、trueの場合、多くの（存在する場合）ブロッキングなしで子スレッドで結合を実行します。

Edit2例外のためにスレッドが終了する場合は、2つのスレッド「メイン」関数があります。最初のスレッドにはtry-catchがあり、その中に2番目の「実際の」メインスレッド関数が呼び出されます。この最初のメイン関数は、「have_exited」変数を設定します。このようなもの：

bool thread_done = false;

void *thread_function(void *arg)
{
    void *res = nullptr;

    try
    {
        res = real_thread_function(arg);
    }
    catch (...)
    {
    }

    thread_done = true;

    return res;
}

結合メソッドでブロックせずにスレッドの終了を検出するために使用できるこの単純なメカニズム。

std::thread thread([&thread]() {
    sleep(3);
    thread.detach();
});

while(thread.joinable())
    sleep(1);

実行中のスレッドと呼び出し元のスレッドの両方がアクセスできるミューテックスを作成します。実行中のスレッドは、開始時にミューテックスをロックし、終了するとミューテックスのロックを解除します。スレッドがまだ実行されているかどうかを確認するために、呼び出し元のスレッドはmutex.try_lock（）を呼び出します。その戻り値はスレッドのステータスです。（try_lockが機能した場合は、必ずミューテックスのロックを解除してください）

これに関する小さな問題の1つである、mutex.try_lock（）は、スレッドが作成されてからミューテックスをロックするまでの間にfalseを返しますが、これは少し複雑な方法を使用して回避できます。

スレッドのIDがデフォルトで構築されたstd :: thread :: id（）と異なるかどうかはいつでも確認できます。実行中のスレッドには、常に本物の関連付けられたIDがあります。派手すぎるものは避けてください:)

確かに、ミューテックスでラップされた変数をに初期化しfalseて、スレッドがtrue終了する前に最後に行うように設定します。それはあなたのニーズに十分な原子ですか？