std::packaged_task

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Thread support library

Threads
thread (C++11)
hardware_destructive_interference_sizehardware_constructive_interference_size (C++17)(C++17)
this_thread namespace
get_id (C++11) yield (C++11)	sleep_for (C++11) sleep_until (C++11)
Mutual exclusion
mutex (C++11) recursive_mutex (C++11) shared_mutex (C++17)	timed_mutex (C++11) recursive_timed_mutex (C++11) shared_timed_mutex (C++14)
Generic lock management
lock_guard (C++11) scoped_lock (C++17) unique_lock (C++11) shared_lock (C++14) defer_lock_ttry_to_lock_tadopt_lock_t (C++11)(C++11)(C++11)	lock (C++11) try_lock (C++11) defer_locktry_to_lockadopt_lock (C++11)(C++11)(C++11) once_flag (C++11) call_once (C++11)
Condition variables
condition_variable (C++11)
condition_variable_any (C++11)
notify_all_at_thread_exit (C++11)
cv_status (C++11)
Futures
promise (C++11) future (C++11) shared_future (C++11) packaged_task (C++11) async (C++11)	launch (C++11) future_status (C++11) future_error (C++11) future_category (C++11) future_errc (C++11)

 

std::packaged_task

Member functions

packaged_task::packaged_task

packaged_task::~packaged_task

packaged_task::operator=

packaged_task::valid

packaged_task::swap

Getting the result

packaged_task::get_future

Execution

packaged_task::operator()

packaged_task::make_ready_at_thread_exit

packaged_task::reset

 

Defined in header <future>
template< class > class packaged_task; //not defined	(1)	(since C++11)
template< class R, class ...Args > class packaged_task<R(Args...)>;	(2)	(since C++11)

The class template std::packaged_task wraps any Callable target (function, lambda expression, bind expression, or another function object) so that it can be invoked asynchronously. Its return value or exception thrown is stored in a shared state which can be accessed through std::future objects.

Just like std::function, std::packaged_task is a polymorphic, allocator-aware container: the stored callable target may be allocated on heap or with a provided allocator.

(until C++17)

Member functions

(constructor)	constructs the task object (public member function)
(destructor)	destructs the task object (public member function)
operator=	moves the task object (public member function)
valid	checks if the task object has a valid function (public member function)
swap	swaps two task objects (public member function)
Getting the result
get_future	returns a std::future associated with the promised result (public member function)
Execution
operator()	executes the function (public member function)
make_ready_at_thread_exit	executes the function ensuring that the result is ready only once the current thread exits (public member function)
reset	resets the state abandoning any stored results of previous executions (public member function)

Non-member functions

std::swap(std::packaged_task) (C++11)

specializes the std::swap algorithm (function template)

Helper classes

std::uses_allocator<std::packaged_task> (C++11)(until C++17)

specializes the std::uses_allocator type trait (class template specialization)

Example

Run this code

#include <iostream>
#include <cmath>
#include <thread>
#include <future>
#include <functional>
 
// unique function to avoid disambiguating the std::pow overload set
int f(int x, int y) { return std::pow(x,y); }
 
void task_lambda()
{
    std::packaged_task<int(int,int)> task([](int a, int b) {
        return std::pow(a, b); 
    });
    std::future<int> result = task.get_future();
 
    task(2, 9);
 
    std::cout << "task_lambda:\t" << result.get() << '\n';
}
 
void task_bind()
{
    std::packaged_task<int()> task(std::bind(f, 2, 11));
    std::future<int> result = task.get_future();
 
    task();
 
    std::cout << "task_bind:\t" << result.get() << '\n';
}
 
void task_thread()
{
    std::packaged_task<int(int,int)> task(f);
    std::future<int> result = task.get_future();
 
    std::thread task_td(std::move(task), 2, 10);
    task_td.join();
 
    std::cout << "task_thread:\t" << result.get() << '\n';
}
 
int main()
{
    task_lambda();
    task_bind();
    task_thread();
}

Output:

task_lambda: 512
task_bind:   2048
task_thread: 1024

See also

future (C++11)

waits for a value that is set asynchronously (class template)