The 2-Minute Rule for sleep
The 2-Minute Rule for sleep
Blog Article
atomic_compare_exchange_weakatomic_compare_exchange_weak_explicitatomic_compare_exchange_strongatomic_compare_exchange_strong_explicit
atomic_compare_exchange_weakatomic_compare_exchange_weak_explicitatomic_compare_exchange_strongatomic_compare_exchange_strong_explicit
This overload could be utilized to ignore spurious awakenings though watching for a certain issue to be real.
remaining - pointer to the thing To place the remaining time on interruption. Can be NULL, wherein case it's dismissed
Although the shared variable is atomic, it must be modified although possessing the mutex to correctly publish the modification on the waiting around thread.
The highest-stage purpose may well converse its return benefit or an exception to your caller via std::promise or by modifying shared variables (which may require synchronization, see std::mutex and std::atomic).
The standard recommends that the clock tied to abs_time be accustomed to measure time; that clock is just not necessary to be described as a monotonic clock. There aren't any ensures concerning the habits of the purpose If your clock is altered discontinuously, but the prevailing implementations transform abs_time from Clock to std::chrono::system_clock and delegate to POSIX pthread_cond_timedwait so the wait around honors adjustments to the procedure clock, although not to your person-presented Clock.
Even though notified below How to get better sleep lock, overload (one) would make no ensures with regards to the condition from the associated predicate when returning due to timeout.
The purpose also may possibly block until finally after sleep_time has long been achieved as a result of method scheduling or resource rivalry delays.
atomic_compare_exchange_weakatomic_compare_exchange_weak_explicitatomic_compare_exchange_strongatomic_compare_exchange_strong_explicit
The category thread represents one thread of execution. Threads permit many functions to execute concurrently.
atomic_compare_exchange_weakatomic_compare_exchange_weak_explicitatomic_compare_exchange_strongatomic_compare_exchange_strong_explicit
Blocks the execution of the current thread for at least until eventually the TIME_UTC based length pointed to by period has elapsed.
This enables the purpose to examine if quit is asked for all through its execution, and return if it has.
When the std::foreseeable future received from std::async is not really moved from or bound to a reference, the destructor from the std::foreseeable future will block at the conclusion of the entire expression until the asynchronous operation completes, primarily generating code which include the subsequent synchronous: