Trouble with multiple std::threads and main program execution

Question

I have been struggling for days to come up with a mechanism for launching a few timers and not having it clock the main program execution. Combinations of .join() and .detach(), wait_until(), etc

What I have is a vector of std::thread and I want to:

• execute the first position
• wait for it to finish
• execute the next position
• wait for it to finish

meanwhile the rest of my app is running along, users clicking things, etc. Everything I come up with seems to either:

• block the main program from running while the timers are going

or

• detach from the main thread but then the timers run concurrently, how I want one after the previous one has finished.

I even posted: C++11 std::threads and waiting for threads to finish but no resolution that I can seem to make sense of either.

should I be using std::launch::async maybe?

EDIT: I am not sure why this is so hard for me to grasp. I mean video games do this all the time. Take Tiny Tower for example. You stock your floors and each one of those operations has a delay from when you start the stock, until when that item is stocked and it triggers a HUD that pops up and says, "Floor is now stocked". Meanwhile the whole game stays running for you to do other things. I must be dense because I cannot figure this out.

Answer 1

This snippet of code will execute a std::vector of nullary tasks in a separate thread.

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) );
}

this should run each of the tasks in series outside the main thread, and return a std::future that contains the timing results.

If you want the timing results in smaller chunks (ie, before they are all ready), you'll have to do more work. I'd start with std::packaged_task and return a std::vector<std::future< timing >> and go from there.

The above code is untested/uncompiled, but shouldn't have any fundamental flaws.

You'll note that the above does not use std::thread. std::thread is a low level tool that you should build tools on top of, not something you should use directly (it is quite fragile due to the requirement that it be joined or detached prior to destruction, among other things).

While std::async is nothing to write home about, it is great for quick-and-dirty multiple threading, where you want to take a serial task and do it "somewhere else". The lack of decent signaling via std::future makes it less than completely general (and is a reason why you might want to write higher level abstractions around std::thread).

Here is one that will run a sequence of tasks with a minimum amount of delay between them:

#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`
}

which should make the helper async thread sleep for (at least as long as) the durations you use before running each task. As written, time taken to execute each task is not counted towards the delays, so if the tasks take longer than the delays, you'll end up with the tasks running with next to no delay between them. Changing that should be easy, if you want to.

Answer 2

Your trouble is understandable, because what you need in order to have timers that don't block your event loop, is an event loop, and C++ doesn't yet have a standard one. You need to use other frameworks (such as Qt, Boost.Asio(?) or non-portable APIs (select(), etc)) to write event loops.