C++11 delay the execution of thread - c++

Question

I'd like to create some threads (with c++11) and collect them in a 'vector'. Then I'd like to fire them up, not immediately upon construction of the associated thread object, but after a specified time. And this is my problem, how can I delay the execution of thread?
It is possible to do something like that? I appreciate any hints.

Answer 1

I'd like to create some threads (with c++11) and collect them in a 'vector'. Then I'd like to fire them up, not immediately upon construction of the associated thread object
You can default construct the std::thread objects:
std::vector<std::thread> threads(some_number);
but after specified time
You can sleep for some time:
std::this_thread::sleep_for(some_time);
Once you're ready to start the execution, create a thread with a function and assign the ones in the vector:
threads[i] = std::thread(some_callable);
That said, creating the empty std::thread objects doesn't necessarily make a lot of sense since you could easily delay creating them until you actually want to execute something.
This approach does make sense when you want to use a constant length array of threads instead of a vector.

Answer 2

My contribution is to provide you a simple working code as all the explanations were already provided by #eerorika perfectly. Please, feel free to look ak the comments within the code
#include <thread>
#include <iostream>
#include <vector>
#include <chrono>
#include <ctime>
/**
* action:
* #param: wait : duration of wating time before launchin an action
* index: index of the thread
**/
void action(int wait, int index)
{
// compute current time
std::time_t result = std::time(nullptr);
// and display it
std::string mytime(std::asctime(std::localtime(&result)));
// only remove the end of line char from the time
mytime.pop_back();
std::cout << "Time is "<< mytime << " Create thread "<< index << " and wait " << (int) (wait/1000) << " seconds "<< std::endl;
// force the thread to wait for the provided amount of time
std::this_thread::sleep_for(std::chrono::milliseconds(wait));
// re-compute current time
std::time_t result2 = std::time(nullptr);
mytime=std::asctime(std::localtime(&result2));
mytime.pop_back();
// and display it
std::cout << "launch action "<< index << " "<< mytime << " after "<< (int)(wait/1000) << " seconds" << std::endl;
}
int main()
{
// a vector composed of 3 threads
std::vector<std::thread> vecOfThreads(3);
vecOfThreads[0]=std::thread(action,5000, 0);
//sleep 15 ms to give the first thread to display his starting message
std::this_thread::sleep_for(std::chrono::milliseconds(15));
// create a thread and provide its runnable (function) and the two arguments of the function
// and assign it to an element of your vector
vecOfThreads[1]=std::thread(action,10000, 1);
//sleep 15 ms to give the first thread to display his starting message
std::this_thread::sleep_for(std::chrono::milliseconds(15));
vecOfThreads[2]=std::thread(action,15000, 2);
//sleep 15 ms to give the first thread to display his starting message
std::this_thread::sleep_for(std::chrono::milliseconds(15));
//waiting for the end of each thread
vecOfThreads[0].join();
vecOfThreads[1].join();
vecOfThreads[2].join();
}

Answer 3

std::async is for such purposes.
// Enable lazy and asynchronous evaluation of func(x, y) on a new thread.
auto a = std::async(std::launch::deferred | std::launch::async, &func, x, y);
// Do what you need.
// It is time to execute func(x, y), wait_for returns immediately without
// waiting regardless of timeout_duration value.
a.wait_for(0s);
// Do other work you need.
// Get the result, wait for a until it is finished if needed.
auto r = a.get();