Namespaces
Variants

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

From cppreference.net
Concurrency support library
Threads
(C++11)
(C++20)
this_thread namespace
(C++11)
(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
void make_ready_at_thread_exit ( ArgTypes... args ) ;
(начиная с C++11)

Вызывает сохранённую задачу, как если бы с помощью INVOKE<R> ( f, args... ) , где f является сохранённой задачей. Возвращаемое значение задачи или любое исключение, выброшенное ею, сохраняется в общем состоянии * this .

Общее состояние становится готовым только после того, как текущий поток завершится и все объекты с продолжительностью хранения в локальной памяти потока будут уничтожены.

Содержание

Параметры

args - параметры для передачи при вызове хранимой задачи

Возвращаемое значение

(нет)

Исключения

std::future_error при следующих условиях ошибки:

  • Сохраненная задача уже была вызвана. Категория ошибки установлена в promise_already_satisfied .
  • * this не имеет общего состояния. Категория ошибки установлена в no_state .

Пример

#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(); // выполнить задачу немедленно
    auto status = state->future.wait_for(std::chrono::seconds(0));
    if (status == std::future_status::timeout)
        std::cout << "worker: future is not ready yet\n";
    else
        std::cout << "worker: future is ready\n";
    std::cout << "worker: exit\n";
}
static std::shared_ptr<ProgramState> create_state()
{
    auto state = std::make_shared<ProgramState>();
    state->task = std::packaged_task<void()>{[]
    {
        std::cout << "task: executed\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: worker finished\n";
    auto status = state->future.wait_for(std::chrono::seconds(0));
    if (status == std::future_status::timeout)
        std::cout << "main: future is not ready yet\n";
    else
        std::cout << "main: future is ready\n";
}

Вывод:

task: executed
worker: future is not ready yet
worker: exit
main: worker finished
main: future is ready

Смотрите также

выполняет функцию
(public member function)