4

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

我拥有的是一个向量，std::thread我想：

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

与此同时，我的应用程序的其余部分正在运行，用户点击事物等。我想出的一切似乎都是：

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

或者

  • 与主线程分离，但随后计时器同时运行，在前一个完成后我想要一个。

我什至发布了：C++11 std::threads 并等待线程完成，但我似乎无法理解任何解决方案。

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

编辑：我不确定为什么这对我来说很难掌握。我的意思是电子游戏一直都在这样做。以小塔为例。您为楼层存货，从您开始存货到该项目存货时，这些操作中的每一个都有延迟，它会触发一个弹出的 HUD 并显示“楼层已存货”。同时整个游戏保持运行，让你做其他事情。我一定很密集，因为我无法弄清楚这一点。

4

2 回答 2

4

这段代码将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包含计时结果的 a。

如果您希望将计时结果分成更小的块（即，在它们都准备好之前），您将不得不做更多的工作。我会从那里开始std::packaged_task并返回 astd::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线程在运行每个任务之前睡眠（至少与您使用的持续时间一样长）。如所写，执行每个任务所花费的时间不计入延迟，因此如果任务花费的时间比延迟长，那么您最终会得到任务运行，它们之间几乎没有延迟。如果你愿意，改变它应该很容易。

于 2013-08-08T21:22:22.617 回答
0

您的麻烦是可以理解的，因为您需要一个不阻塞事件循环的计时器，而 C++ 还没有标准的事件循环。您需要使用其他框架（例如 Qt、Boost.Asio(?) 或不可移植的 API（select() 等））来编写事件循环。

于 2013-11-04T11:04:46.020 回答