c++ - 使用 std::chrono::duration 跟踪超时

Question

我有一个函数，它以 long 的形式接收超时发生前的微秒数。此超时是函数完成其工作的超时，即使由于调度和其他开销等原因，函数可能需要比超时更长的时间。

该函数执行以下操作:

1. 使用 std::future 和 std::async 执行一些设置并启动多个线程。
2. 在循环中使用 std::future::wait_for() 跟踪线程。基本上，我对每次调用 wait_for() 进行计时，然后从超时中减去它所花费的时间。然后在检查下一个线程时使用这个新超时。我的目标是确保我启动的所有线程在超时(即传递给函数的超时参数)到期之前完成它们的工作。

伪代码如下:

void myFunctionWithTimeout(/*some other inputs*/ const long timeout_us) {
  auto start_time = std::chrono::steady_clock::now();
  double time_remaining_us = std::chrono::microseconds(timeout_us).count();

  // Launch threads here using std::future and std::async...

  auto end_time = std::chrono::steady_clock::now();
  const auto setup_time_us =
    std::chrono::duration<double, std::micro>(end_time - start_time);
  time_remaining_us -= setup_time_us.count();

  for(auto& worker : workers) {
    auto start_time = std::chrono::steady_clock::now();
    const auto status =
      worker.wait_for(std::chrono::duration<double, std::micro>(time_remaining_us));
    auto end_time = std::chrono::steady_clock::now();

    // Check status and do the appropriate actions.
    // Note that it is OK that this time isn't part of the timeout.

    const auto wait_time_us =
      std::chrono::duration<double, std::micro>(end_time - start_time);
    time_remaining_us -= wait_time_us.count();
  }
}

我的问题:

1. 有没有更简单的方法来实现我的提议？我的目标是将剩余时间存储为 double，以便在各种计算中我可以计算微秒的分数。请注意，我知道 wait_for() 不会完全等待我指定的持续时间，因为调度和其他原因，但至少，我不想添加任何舍入我的计算有误。
2. 与 #1 相关:我是否需要每次都获取计数，或者是否有一种干净的方法来更新 std::chrono::duration？我希望将剩余时间存储为持续时间，然后从中减去设置时间或等待时间。
3. 当 time_remaining_us 变为负数时会发生什么？这对 std::chrono::duration 的构造函数有何影响？将负持续时间传递给 std::future::wait_for() 时会发生什么？我没有在文档中找到这些详细信息，并且想知道此处的行为是否定义明确。

============================================= ======================编辑添加:

根据 Howard 的回答，我研究了使用 wait_until()，但由于我在研究中发现的以下问题(摘自:https://en.cppreference.com/w/cpp/thread/future/wait_until)，我认为它对我不起作用):

The clock tied to timeout_time is used, which is not required to be a monotonic clock.There are no guarantees regarding the behavior of this function if the clock is adjusted discontinuously, but the existing implementations convert timeout_time from Clock to std::chrono::system_clock and delegate to POSIX pthread_cond_timedwait so that the wait honors ajustments to the system clock, but not to the the user-provided Clock. In any case, the function also may wait for longer than until after timeout_time has been reached due to scheduling or resource contention delays.

我的理解是，即使我使用 steady_clock 作为我的结束时间，它也会被转换为 system_clock，这意味着如果时钟被调整(比如说回滚一个小时)我最终可能会超时，比我预期的要长得多。

也就是说，我确实采用了计算结束时间的概念，它简化了我的代码。这是我目前所处位置的一些伪代码:

void myFunctionWithTimeout(/*some other inputs*/ const long timeout_us) {
  const auto start_time = std::chrono::steady_clock::now();
  const auto end_time =
    start_time + std::chrono::duration<double, std::micro>(timeout_us);

  // Launch threads here using std::future and std::async...

  for(auto& worker : workers) {
    const auto current_timeout_us =
      std::chrono::duration<double, std::micro>(end_time - std::chrono::steady_clock::now());
    if (current_timeout_us.count() <= 0) {  // Is this needed?
      // Handle timeout...
    }
    const auto status = worker.wait_for(current_timeout_us);

    // Check status and do the appropriate actions...
  }
}

我仍然不确定是否可以将负持续时间传递给 wait_for()，所以我先手动检查。如果有人知道 wait_for() 是否可以接受负持续时间，请告诉我。另外，如果我对 wait_until() 的文档的理解不正确，也请告诉我。

Answer 1

只需使用 wait_until 而不是 wait_for。计算您要等到一次的 time_point，并继续使用它。如果 time_point 开始落入过去，wait_until 将立即返回。