std::future<T>:: wait_until

wait_until attend qu'un résultat soit disponible. Il se bloque jusqu'à ce que le timeout_time spécifié soit atteint ou que le résultat devienne disponible, selon la première éventualité. La valeur de retour indique pourquoi wait_until a retourné.

Si le futur est le résultat d'un appel à async qui a utilisé l'évaluation paresseuse, cette fonction retourne immédiatement sans attendre.

Le comportement est indéfini si valid() est false avant l'appel à cette fonction, ou si Clock ne satisfait pas aux exigences Clock . Le programme est mal formé si std:: chrono :: is_clock_v < Clock > est false . (depuis C++20)

Paramètres

Valeur de retour

Exceptions

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

Notes

Les implémentations sont encouragées à détecter le cas où valid ( ) == false avant l'appel et à lever une std::future_error avec une condition d'erreur de future_errc::no_state .

La norme recommande que l'horloge associée à timeout_time soit utilisée pour mesurer le temps ; cette horloge n'est pas requise d'être une horloge monotone. Il n'y a aucune garantie concernant le comportement de cette fonction si l'horloge est ajustée de manière discontinue, mais les implémentations existantes convertissent timeout_time de Clock vers std::chrono::system_clock et délèguent à pthread_cond_timedwait POSIX afin que l'attente prenne en compte les ajustements de l'horloge système, mais pas ceux de l'horloge Clock fournie par l'utilisateur. Dans tous les cas, la fonction peut également attendre au-delà du moment où timeout_time a été atteint en raison de délais de planification ou de contention des ressources.

Exemple

#include <chrono>
#include <future>
#include <iostream>
#include <thread>
int main()
{
    std::chrono::system_clock::time_point two_seconds_passed
        = std::chrono::system_clock::now() + std::chrono::seconds(2);
    // Créer un future qui prend 1 seconde à se terminer
    std::promise<int> p1;
    std::future<int> f_completes = p1.get_future();
    std::thread([](std::promise<int> p1)
                { 
                    std::this_thread::sleep_for(std::chrono::seconds(1)); 
                    p1.set_value_at_thread_exit(9); 
                }, 
                std::move(p1)
    ).detach();
    // Créer un future qui prend 5 secondes à se terminer
    std::promise<int> p2;
    std::future<int> f_times_out = p2.get_future();
    std::thread([](std::promise<int> p2)
                { 
                    std::this_thread::sleep_for(std::chrono::seconds(5)); 
                    p2.set_value_at_thread_exit(8); 
                }, 
                std::move(p2)
    ).detach();
    std::cout << "En attente pendant 2 secondes..." << std::endl;
    if (std::future_status::ready == f_completes.wait_until(two_seconds_passed))
        std::cout << "f_completes: " << f_completes.get() << "\n";
    else
        std::cout << "f_completes ne s'est pas terminé !\n";
    if (std::future_status::ready == f_times_out.wait_until(two_seconds_passed))
        std::cout << "f_times_out: " << f_times_out.get() << "\n";
    else
        std::cout << "f_times_out ne s'est pas terminé !\n";
    std::cout << "Terminé !\n";
}

En attente pendant 2 secondes...
f_completes: 9
f_times_out ne s'est pas terminé !
Terminé !

Voir aussi