thread.join（）的超时 [英] Timeout for thread.join()

问题描述

是否可以为 std :: thread :: join（）调用设置超时？我想处理线程运行时间过长或终止线程的情况。我可能正在为多线程（比如说，多达30）这样做。

Is it possible to set a timeout for a call to std::thread::join()? I want to handle the case in which the thread is taking too long to run, or terminate the thread. I may be doing this for multiple threads (say, up to 30).

最好没有boost，但我会感兴趣的是boost解决方案，如果这是最好的方法。

Preferably without boost, but I'd be interested in a boost solution if that's the best way.

推荐答案

std :: thread :: join $ c>。但是，您可以将 std :: thread :: join（）视为一个方便的函数。使用 condition_variable ，您可以在线程之间创建非常丰富的通信和协作，包括定时等待。例如：

There is no timeout for std::thread::join(). However you can view std::thread::join() as merely a convenience function. Using condition_variables you can create very rich communication and cooperation between your threads, including timed waits. For example:

#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 启动几个线程做工作，所有这些都偶尔检查是否是时候退出互斥（这也可以是一个原子）。主线程还监视是否是退出的时间（如果线程完成了所有的工作）。如果主机耗尽了耐心，他只是声明它是退出的时间，然后等待所有线程执行任何必要的清理后退出。

In this example main launches several threads to do work, all of which occasionally check if it is time to quit under a mutex (this could also be an atomic). The main thread also monitors if it is time to quit (if the threads get all their work done). If main runs out of patience, he just declares it to be time to quit, then waits for all threads to perform any necessary clean up before exiting.

这篇关于thread.join（）的超时的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！