Difference between revisions of "cpp/thread/packaged task"

Revision as of 07:28, 7 February 2013

Template:ddcl list begin <tr class="t-dsc-header">

<td>

Defined in header <future>

</td>

<td >

template< class > class packaged_task; //not defined

</td>

<td > (1) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >

template< class R, class Args... >
class packaged_task<R(Args...)>;

</td>

<td > (2) </td> <td > (since C++11) </td> </tr> Template:ddcl list end

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.

Template:cpp/thread/packaged task/dcl list constructor Template:cpp/thread/packaged task/dcl list destructor Template:cpp/thread/packaged task/dcl list operator=Template:cpp/thread/packaged task/dcl list valid Template:cpp/thread/packaged task/dcl list swap Template:cpp/thread/packaged task/dcl list get future Template:cpp/thread/packaged task/dcl list operator()Template:cpp/thread/packaged task/dcl list make ready at thread exit Template:cpp/thread/packaged task/dcl list reset

Getting the result
Execution

Non-member functions

Template:cpp/thread/packaged task/dcl list swap2

Helper classes

Template:cpp/thread/packaged task/dcl list uses allocator

Example

Run this code

#include <iostream>
#include <cmath>
#include <thread>
#include <future>
 
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(std::pow, 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(std::pow);
    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

@@ Line 51: / Line 51: @@
 #include <future>
-/**
+void task_lambda()
- * Use operator() to do the work
- */
-void example1()
 {
-	// wrap the function using lambda
+    std::packaged_task<int(int,int)> task([](int a, int b) {
-	std::packaged_task<int(int,int)> task([](int _one,int _two) {
+        return std::pow(a, b);
-			return pow(_one, _two); });
+    });
-	std::future<int> result = task.get_future();
+    std::future<int> result = task.get_future();
-	task(2, 9);
+    task(2, 9);
-	std::cout << "example1:" << std::endl;
+    std::cout << "task_lambda:\t" << result.get() << '\n';
-	std::cout << result.get() << std::endl;
+}
-}//example1()
-/**
+void task_bind()
- * Use thread to do the work.
- * Remember to use move semantics, and pass the arguments.
- */
-void example2()
 {
-	std::packaged_task<int(int,int)> task(pow);
+    std::packaged_task<int()> task(std::bind(std::pow, 2, 11));
-	auto result = task.get_future(); // auto -> std::future<int>
+    std::future<int> result = task.get_future();
-	std::thread task_td(std::move(task), 2, 10);
+    task();
-	task_td.join();
-	std::cout << "example2:" << std::endl;
+    std::cout << "task_bind:\t" << result.get() << '\n';
-	std::cout << result.get() << std::endl;
+}
-}//example2()
-/**
+void task_thread()
- * Use std::bind to bind arguments
- */
-void example3()
 {
-	std::packaged_task<int()> task(std::bind(pow, 2, 11));
+    std::packaged_task<int(int,int)> task(std::pow);
-	auto result = task.get_future(); // auto -> std::future<int>
+    std::future<int> result = task.get_future();
-	task(); // It will work the same for using thread
+    std::thread task_td(std::move(task), 2, 10);
+    task_td.join();
-	std::cout << "example3:" << std::endl;
+    std::cout << "task_thread:\t" << result.get() << '\n';
-	std::cout << result.get() << std::endl;
+}
-}//example3()
 int main()
 {
-	example1();
+    task_lambda();
-	example2();
+    task_bind();
-	example3();
+    task_thread();
+}
-	return 0;
-}//main
 | output=
-example1:
+task_lambda: 512
+task_bind:   2048
-example2:
+task_thread: 1024
-example3:
 }}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

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
Non-member functions
swap(std::packaged_task)
Helper classes
uses_allocator<std::packaged_task> (until C++17)
Deduction guides(C++17)

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/thread/packaged task"

Revision as of 07:28, 7 February 2013

Contents

Member functions

Getting the result

Execution

Non-member functions

Helper classes

Example

See also

Navigation

Toolbox