In this article we will discuss how to put a c++11 thread to sleep.
c++11 provides 2 functions for putting a thread to sleep i.e.
std::this_thread::sleep_for std::this_thread::sleep_untill
Sleep for a Duration
C++11 provides a function std::this_thread::sleep_for to block the current thread for specified duration i.e.
template <class Rep, class Period> void sleep_for (const chrono::duration<Rep,Period>& rel_time);
This function accepts a duration as an argument and make the calling thread to sleep for that particular duration.
Frequently Asked:
This duration can be from nanoseconds to hours i.e.
std::chrono::nanoseconds std::chrono::microseconds std::chrono::milliseconds std::chrono::seconds std::chrono::minutes std::chrono::hours
Lets see some examples,
Sleeping a Thread for MilliSeconds:
To sleep a thread for 200 Milliseconds call sleep_for with following argument i.e.
Best Resources to Learn C++:
std::this_thread::sleep_for(std::chrono::milliseconds(200));
Sleeping a Thread for Minutes:
To sleep a thread for 1 Minute call sleep_for with following argument i.e.
std::this_thread::sleep_for(std::chrono::minutes(1));
Checkout complete example as follows,
#include <iostream>
#include <thread>
#include <chrono>
void threadFunc()
{
int i = 0;
while (i < 10)
{
// Print Thread ID and Counter i
std::cout<<std::this_thread::get_id()<<" :: "<<i++<<std::endl;
// Sleep this thread for 200 MilliSeconds
std::this_thread::sleep_for(std::chrono::milliseconds(200));
}
}
int main()
{
std::thread th(&threadFunc);
th.join();
return 0;
}
Output:
140484807997184 :: 0 140484807997184 :: 1 140484807997184 :: 2 140484807997184 :: 3 140484807997184 :: 4 140484807997184 :: 5 140484807997184 :: 6 140484807997184 :: 7 140484807997184 :: 8 140484807997184 :: 9
Sleep Until a TimePoint
Many times we want the thread to sleep untill a time point in future. That can be acieved using sleep_untill() i.e.
template< class Clock, class Duration > void sleep_until( const std::chrono::time_point<Clock,Duration>& sleepTime );
It accepts a time point as an argument and blocks the current thread till this time point is achieved.
Checkout the complete example, here we will put a thread to sleep until a time point in future i.e.
#include <iostream>
#include <thread>
#include <chrono>
// Print Current Time
void print_time_point(std::chrono::system_clock::time_point timePoint)
{
std::time_t timeStamp = std::chrono::system_clock::to_time_t(timePoint);
std::cout << std::ctime(&timeStamp) << std::endl;
}
void threadFunc()
{
std::cout<<"Current Time :: ";
// Print Current Time
print_time_point(std::chrono::system_clock::now());
// create a time point pointing to 10 second in future
std::chrono::system_clock::time_point timePoint =
std::chrono::system_clock::now() + std::chrono::seconds(10);
std::cout << "Going to Sleep Until :: "; print_time_point(timePoint);
// Sleep Till specified time point
// Accepts std::chrono::system_clock::time_point as argument
std::this_thread::sleep_until(timePoint);
std::cout<<"Current Time :: ";
// Print Current Time
print_time_point(std::chrono::system_clock::now());
}
int main()
{
std::thread th(&threadFunc);
th.join();
return 0;
}
Output:
Current Time :: Sat Feb 25 16:44:40 2017 Going to Sleep Until :: Sat Feb 25 16:44:50 2017 Current Time :: Sat Feb 25 16:44:50 2017