c++ - 多个 std::threads 和主程序执行的问题

Question

几天来，我一直在努力想出一种机制来启动一些计时器，而不是让它为主程序执行计时。 .join() 和.detach()、wait_until() 等的组合

我有一个 std::thread 的 vector ，我想:

• 执行第一个位置
• 等待它完成
• 执行下一个位置
• 等待它完成

与此同时，我的应用程序的其余部分正在运行，用户点击东西等。我想出的一切似乎要么:

• 在计时器运行时阻止主程序运行

或

• 从主线程分离，但计时器同时运行，我多么希望在前一个完成后再运行一个。

我什至发布了:C++11 std::threads and waiting for threads to finish但我似乎无法理解任何一个解决方案。

我应该使用 std::launch::async 吗？

编辑:我不确定为什么这对我来说如此难以理解。我的意思是视频游戏一直都在这样做。以小塔为例。你在你的地板上存货，这些操作中的每一个都有延迟，从你开始存货到该元素被存货并触发一个 HUD 弹出并说“地板现在已存货”。同时整个游戏保持运行，让你做其他事情。我一定很笨，因为我想不通。

Answer 1

这段代码将执行 std::vector在单独的线程中执行无效任务。

typedef std::vector<std::function< void() >> task_list;
typedef std::chrono::high_resolution_clock::duration timing;
typedef std::vector< timing > timing_result;

timing_result do_tasks( task_list list ) {
  timing_result retval;
  for (auto&& task: list) {
    std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
    task();
    std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now();
    retval.push_back( end-start );
  }
  return retval;
}
std::future<timing_result> execute_tasks_in_order_elsewhere( task_list list ) {
  return std::async( std::launch::async, do_tasks, std::move(list) );
}

这应该在主线程之外依次运行每个任务，并返回 std::future包含计时结果。

如果您希望计时结果更小(即，在它们全部准备好之前)，您将需要做更多的工作。我将从 std::packaged_task 开始并返回 std::vector<std::future< timing >>然后从那里开始。

以上代码未经测试/未编译，但不应有任何根本性缺陷。

你会注意到上面没有使用 std::thread . std::thread是一个低级工具，你应该在其上构建工具，而不是你应该直接使用的东西(它非常脆弱，因为它需要在销毁之前被 join 编辑或 detach 编辑等等)。

同时 std::async没有什么值得大书特书的，它非常适合快速而肮脏的多线程，您可以在其中执行串行任务并在“其他地方”执行。通过 std::future 缺乏体面的信号使它不那么通用(这也是您可能想要围绕 std::thread 编写更高级别抽象的原因)。

这是一个将运行一系列任务的任务，它们之间的延迟量最小:

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

typedef std::chrono::high_resolution_clock::duration duration;
typedef std::chrono::high_resolution_clock::time_point time_point;
typedef std::vector<std::pair<duration, std::function< void() >>> delayed_task_list;

void do_delayed_tasks( delayed_task_list list ) {
  time_point start = std::chrono::high_resolution_clock::now();
  time_point last = start;
  for (auto&& task: list) {
    time_point next = last + task.first;
    duration wait_for = next - std::chrono::high_resolution_clock::now();
    std::this_thread::sleep_for( wait_for );
    task.second();
    last = next;
  }
}
std::future<void> execute_delayed_tasks_in_order_elsewhere( delayed_task_list list ) {
  return std::async( std::launch::async, do_delayed_tasks, std::move(list) );
}
int main() {
  delayed_task_list meh;
  meh.emplace_back( duration(), []{ std::cout << "hello world\n"; } );
  std::future<void> f = execute_delayed_tasks_in_order_elsewhere( meh );
  f.wait(); // wait for the task list to complete: you can instead store the `future`
}

这应该使助手 async线程 sleep (至少只要)您在运行每个任务之前使用的持续时间。正如所写，执行每项任务所花费的时间不计入延迟，因此如果任务花费的时间比延迟时间长，您最终会在任务之间几乎没有延迟的情况下运行这些任务。如果您愿意，更改它应该很容易。