Namespaces
Variants

std::this_thread:: sleep_for

From cppreference.net
Concurrency support library
Threads
(C++11)
(C++20)
this_thread namespace
(C++11)
(C++11)
sleep_for
(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 Rep, class Period >
void sleep_for ( const std:: chrono :: duration < Rep, Period > & sleep_duration ) ;
(depuis C++11)

Bloque l'exécution du thread actuel pendant au moins la durée spécifiée sleep_duration .

Cette fonction peut bloquer plus longtemps que sleep_duration en raison de délais de planification ou de conflits de ressources.

La norme recommande qu'une horloge stable soit utilisée pour mesurer la durée. Si une implémentation utilise plutôt une horloge système, le temps d'attente peut également être sensible aux ajustements de l'horloge.

Table des matières

Paramètres

sleep_duration - durée de temps de sommeil

Valeur de retour

(aucun)

Exceptions

Toute exception levée par clock , time_point , ou duration pendant l'exécution (les horloges, points temporels et durées fournis par la bibliothèque standard ne lèvent jamais d'exception).

Exemple

#include <chrono>
#include <iostream>
#include <thread>
int main()
{
    using namespace std::chrono_literals;
    std::cout << "Hello waiter\n" << std::flush;
    const auto start = std::chrono::high_resolution_clock::now();
    std::this_thread::sleep_for(2000ms);
    const auto end = std::chrono::high_resolution_clock::now();
    const std::chrono::duration<double, std::milli> elapsed = end - start;
    std::cout << "Waited " << elapsed << '\n';
}

Sortie possible :

Hello waiter
Waited 2000.13 ms

Voir aussi

interrompt l'exécution du thread courant jusqu'à un point temporel spécifié
(fonction)