std::packaged_task<R(Args...)>:: make_ready_at_thread_exit

Appelle la tâche stockée comme si par INVOKE<R> ( f, args... ) , où f est la tâche stockée. La valeur de retour de la tâche ou toute exception levée par celle-ci est stockée dans l'état partagé de * this .

L'état partagé n'est rendu prêt qu'après que le thread actuel se termine et que tous les objets de durée de stockage thread-local sont détruits.

Paramètres

Valeur de retour

(aucun)

Exceptions

std::future_error sur les conditions d'erreur suivantes :

• La tâche stockée a déjà été invoquée. La catégorie d'erreur est définie sur promise_already_satisfied .
• * this n'a pas d'état partagé. La catégorie d'erreur est définie sur no_state .

Exemple

#include <chrono>
#include <functional>
#include <future>
#include <iostream>
#include <memory>
#include <thread>
#include <utility>
struct ProgramState
{
    std::packaged_task<void()> task;
    std::future<void> future;
    std::thread worker;
};
static void worker(std::shared_ptr<ProgramState> state)
{
    state->task.make_ready_at_thread_exit(); // exécuter la tâche immédiatement
    auto status = state->future.wait_for(std::chrono::seconds(0));
    if (status == std::future_status::timeout)
        std::cout << "worker: le future n'est pas encore prêt\n";
    else
        std::cout << "worker: le future est prêt\n";
    std::cout << "worker: sortie\n";
}
static std::shared_ptr<ProgramState> create_state()
{
    auto state = std::make_shared<ProgramState>();
    state->task = std::packaged_task<void()>{[]
    {
        std::cout << "task: exécuté\n";
    }};
    state->future = state->task.get_future();
    state->worker = std::thread{worker, state};
    return state;
}
int main()
{
    auto state = create_state();
    state->worker.join();
    std::cout << "main: travailleur terminé\n";
    auto status = state->future.wait_for(std::chrono::seconds(0));
    if (status == std::future_status::timeout)
        std::cout << "main: le future n'est pas encore prêt\n";
    else
        std::cout << "main: le future est prêt\n";
}

task: exécuté
worker: le future n'est pas encore prêt
worker: sortie
main: travailleur terminé
main: le future est prêt

Voir aussi