使用超时调用方法

Question

我想要的是调用一个方法 foo() 超时（比如 1 分钟）。如果其执行时间少于 1 分钟，则返回结果。否则会抛出异常。代码如下：

//PRINT "START" IN THE LOG
auto m = std::make_shared<std::mutex>();
auto cv = std::make_shared<std::condition_variable>();
auto ready = std::make_shared<bool>(false);
auto response = std::make_shared<TResponse>();
auto exception = std::make_shared<FooException>();
exception->Code = ErrorCode::None;

std::thread([=]
{
    std::unique_lock<std::mutex> lk(*m);
    cv->wait(lk, [=]{ return *ready; });

    try
    {
        //PRINT "PROCESS" IN THE LOG
        auto r = foo();
        *response = std::move(r);
    }
    catch(const FooException& e)
    {
        *exception = std::move(e);
    }

    lk.unlock();
    cv->notify_one();
}).detach();

std::unique_lock<std::mutex> lk(*m);
*ready = true;
cv->notify_one();
auto status = cv->wait_for(lk, std::chrono::seconds(60));
if (status == std::cv_status::timeout)
{
    //PRINT "TIMEOUT" IN THE LOG
    //throw timeout exception
}
else
{
    //PRINT "FINISH" IN THE LOG
    if (exception->Code == ErrorCode::None)
    {
        return *response;
    }
    else
    {
        throw *exception;
    }
}

您可以看到我在代码中添加了日志START/PROCESS/FINISH/TIMEOUT，每次执行此方法时，我都可以在日志中看到START/PROCESS/FINISH 或START/PROCESS/TIMEOUT 模式。但是，有时日志是 START/PROCESS，没有任何 FINISH/TIMEOUT。我认为cv->wait_for 应该最多阻塞当前线程 60 秒，然后它存在 TIMEOUT 或 FINISH。

foo() 方法包含对网络驱动器的磁盘 IO 操作，有时会挂起超过 1 小时（原因与此问题无关，现在无法解决），我尝试替换 foo使用线程睡眠，一切都按预期工作。这段代码有什么问题，我该如何改进？

Answer 1

因为cv->wait_for 调用中没有谓词，线程可能被虚假地解除阻塞。但是，奇怪的是没有打印 FINISH/TIMEOUT。所以我们可能需要更多信息：程序发生了什么？是否挂起，是否抛出，是否刚刚退出，是否在cv->wait_for 之后的行中打印？

您可以尝试使用std::async 并查看是否出现相同的行为（此外，它会大大简化您的代码）：

std::future<int> res = std::async(foo);

std::future_status stat = res.wait_for(std::chrono::seconds(60));

if (stat != std::future_status::ready) {
  std::cout << "Timed out..." << "\n";
} else {
  try {
    int result = res.get();
    std::cout << "Result = " << result << std::endl;
  } catch (const FooException& e) {
    std::cerr << e.what() << '\n';
  }
}

---

编辑 正如 CuriouslyRecurringThoughts 在 cmets 中指出的那样，std::async 块在析构函数中的未来。如果这不是一个选项，下面的代码使用 std::promise 和一个分离的线程来代替：

std::promise<int> prom;
std::future<int> res = prom.get_future();

std::thread([p = std::move(prom)]() mutable {
  try {
    p.set_value(foo());
  } catch (const std::exception& e) {
    p.set_exception(std::current_exception());
  }
}).detach();

等待std::future 如前所示完成。

Answer 2

似乎尽管定时等待您的主线程死锁，因为即使cv->wait_for 超时返回，它仍会尝试在当前被第二个线程锁定的互斥锁上使用lk.lock()。

正如cppreference 中提到的关于wait_for：

解除阻塞后，无论出于何种原因，都会重新获取锁定并退出 wait_for()。

我不确定为什么 promise/future 解决方案对您不起作用，因为您没有在此处发布该示例，但我尝试了它的简单版本，即使在第二个线程“挂起”：

using namespace std::chrono_literals;

std::cout << "START" << std::endl;
std::promise<void> p;
auto f = p.get_future();
std::thread t([p = std::move(p)]() mutable {
    std::cout << "PROCESS" << std::endl;
    std::this_thread::sleep_for(5min);
    p.set_value();
});

auto status = f.wait_for(5s);
std::cout << (status == std::future_status::ready ? "FINISH" : "TIMEOUT") << std::endl;
t.join();

输出如预期：

START
PROCESS
TIMEOUT

Answer 3

我们可以创建一个单独的线程来运行调用本身，并在主线程中等待返回的条件变量，一旦返回，调用 foo 的线程将发出信号。

诀窍是在 60 秒超时的情况下等待条件变量，这样如果调用花费的时间超过超时时间，您仍然会醒来，了解它并能够抛出异常 - 全部在主线程中.

请在下面找到一个代码示例：

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <condition_variable>

using namespace std::chrono_literals;

int foo()
{

    //std::this_thread::sleep_for(10s); //Will Return  Success
    std::this_thread::sleep_for(70s); //Will Return  Timeout
    return 1;
}

int foo_wrapper()
{
    std::mutex m;
    std::condition_variable cv;
    int retValue;

    std::thread t([&cv, &retValue]() 
    {
        retValue = foo();
        cv.notify_one();
    });

    t.detach();

    {
        std::unique_lock<std::mutex> lock(m);
        if(cv.wait_for(lock, 60s) == std::cv_status::timeout) 
            throw std::runtime_error("Timeout");
    }

    return retValue;    
}

int main()
{
    bool timedout = false;
    try {
        foo_wrapper();
    }
    catch(std::runtime_error& e) {
        std::cout << e.what() << std::endl;
        timedout = true;
    }

    if(!timedout)
        std::cout << "Success" << std::endl;
    else
        std::cout << "Failure" << std::endl;

    return 0;
}

如果我们在foo 中使用std::this_thread::sleep_for(10s); 将返回SUCCESS 而且，如果我们在foo 中使用std::this_thread::sleep_for(70s); 将返回TIMEOUT

希望对你有帮助！

Answer 4

正如 Mike van Dyke 所说，documentation 非常清楚，您需要一个谓词来正确使用条件变量，以处理虚假唤醒：

当通知条件变量、超时过期或发生虚假唤醒时，线程被唤醒，互斥量被原子地重新获取。 线程应该检查条件并在唤醒是虚假的情况下继续等待。

任何使用 condvar 来等待 循环和谓词都是错误的。它应该总是有一个明确的while(!predicate)循环或者看起来像：

std::unique_lock<std::mutex> lk(*m);
auto status = cv->wait_for(lk, std::chrono::seconds(60), predicate);
if (status == std::cv_status::timeout)
{ /*...*/ } else { /*...*/ }

这意味着您需要检查一些谓词：在通知线程中的 condvar 之前设置 *ready = false（并使用 !*ready 作为谓词）就可以了。

至于为什么您没有看到预期的结果-我不知道，因为我看不到您的真实日志记录代码或您提供的代码 sn-p 之外发生的情况。从wait_for 唤醒而没有超时或收到有效响应或异常是最有可能的，但您必须调试您的代码或提供一个完整的示例来帮助解决这个问题。