Namespaces
Variants

std::this_thread:: sleep_until

From cppreference.net
Concurrency support library
Threads
(C++11)
(C++20)
this_thread namespace
(C++11)
(C++11)
(C++11)
sleep_until
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
Semaphores
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
Atomic types
(C++11)
(C++20)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
Memory ordering
(C++11) (deprecated in C++26)
Free functions for atomic operations
Free functions for atomic flags
Défini dans l'en-tête <thread>
template < class Clock, class Duration >
void sleep_until ( const std:: chrono :: time_point < Clock, Duration > & sleep_time ) ;
(depuis C++11)

Bloque l'exécution du thread actuel jusqu'à ce que le sleep_time spécifié soit atteint.

Clock doit satisfaire aux exigences Clock . Le programme est mal formé si std:: chrono :: is_clock_v < Clock > est false . (depuis C++20)

La norme recommande que l'horloge liée à sleep_time soit utilisée, auquel cas les ajustements de l'horloge peuvent être pris en compte. Ainsi, la durée du bloc pourrait être supérieure ou inférieure à sleep_time - Clock :: now ( ) au moment de l'appel, selon la direction de l'ajustement et s'il est respecté par l'implémentation. La fonction peut également bloquer jusqu'à ce que sleep_time soit atteint en raison de la planification des processus ou des délais de contention des ressources.

Table des matières

Paramètres

sleep_time - temps à bloquer jusqu'à

Valeur de retour

(aucun)

Exceptions

Toute exception levée par Clock ou Duration (les horloges et durées fournies par la bibliothèque standard ne lèvent jamais d'exception).

Exemple

#include <chrono>
#include <iostream>
#include <thread>
auto now() { return std::chrono::steady_clock::now(); }
auto awake_time()
{
    using std::chrono::operator""ms;
    return now() + 2000ms;
}
int main()
{
    std::cout << "Hello, waiter...\n" << std::flush;
    const auto start{now()};
    std::this_thread::sleep_until(awake_time());
    std::chrono::duration<double, std::milli> elapsed{now() - start};
    std::cout << "Waited " << elapsed.count() << " ms\n";
}

Sortie possible :

Hello, waiter...
Waited 2000.17 ms

Voir aussi

(C++11)
interrompt l'exécution du thread courant pour une durée spécifiée
(fonction)
documentation C pour thrd_sleep