std::packaged_task

• A stored task, which is some callable object (such as a function pointer, pointer to member or function object) whose call signature shall take arguments of the types in Args... and return a value of type Ret.
• A shared state, which is able to store the results of calling the stored task (of type Ret) and be accessed asynchronously through a future.

Member functions

(constructor)

Construct packaged task (public member function)

(destructor)

Destroy packaged task (public member function)

operator=

Move-assign packaged_task (public member function)

valid

Check for valid shared state (public member function)

get_future

Get future (public member function)

operator()

Call stored task (public member function)

make_ready_at_thread_exit

Call stored task and make ready at thread exit (public member function)

reset

Reset task (public member function)

swap

Swap packaged_task (public member function)

Non-member function overloads

swap (packaged_task)

Swap packaged_task (function template)

Non-member class specializations

uses_allocator<packaged_task>

Uses allocator for packaged_task (class template)

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// packaged_task example
#include <iostream>     // std::cout
#include <future>       // std::packaged_task, std::future
#include <chrono>       // std::chrono::seconds
#include <thread>       // std::thread, std::this_thread::sleep_for
// count down taking a second for each value:
int countdown (int from, int to) {
  for (int i=from; i!=to; --i) {
    std::cout << i << '\n';
    std::this_thread::sleep_for(std::chrono::seconds(1));
  }
  std::cout << "Lift off!\n";
  return from-to;
}
int main ()
{
  std::packaged_task<int(int,int)> tsk (countdown);   // set up packaged_task
  std::future<int> ret = tsk.get_future();            // get future
  std::thread th (std::move(tsk),10,0);   // spawn thread to count down from 10 to 0
  // ...
  int value = ret.get();                  // wait for the task to finish and get result
  std::cout << "The countdown lasted for " << value << " seconds.\n";
  th.join();
  return 0;
}

10
9
8
7
6
5
4
3
2
1
Lift off!
The countdown lasted for 10 seconds.