std::async

来自cppreference.com

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

 
C++
 
线程的支持库
主题
Original:
Threads
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
thread（C++11）
this_thread命名空间
Original:
this_thread namespace
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
get_id（C++11）
yield（C++11）
sleep_for（C++11）
sleep_until（C++11）
相互排斥
Original:
Mutual exclusion
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
mutex（C++11）
timed_mutex（C++11）
recursive_mutex（C++11）
recursive_timed_mutex（C++11）
通用锁管理
Original:
Generic lock management
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
lock_guard（C++11）
unique_lock（C++11）
defer_lock_t
try_to_lock_t
adopt_lock_t		（C++11）
（C++11）
（C++11）
lock（C++11）
try_lock（C++11）
defer_lock
try_to_lock
adopt_lock		（C++11）
（C++11）
（C++11）
条件变量
Original:
Condition variables
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
condition_variable（C++11）
condition_variable_any（C++11）
notify_all_at_thread_exit（C++11）
cv_status（C++11）
期货
Original:
Futures
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
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）
 
Defined in header <future>
template< class Function, class... Args>

std::future<typename std::result_of<Function(Args...)>::type>

    async( Function&& f, Args&&... args );
 (1) （C++11 起）
template< class Function, class... Args >

std::future<typename std::result_of<Function(Args...)>::type>

    async( std::launch policy, Function&& f, Args&&... args );
 (2) （C++11 起）
。模板功能asyncf异步运行的功能（可能在一个单独的线程），并返回一个std::future，最终将持有该函数调用的结果.
Original:
The template function async runs the function f asynchronously (potentially in a separate thread) and returns a std::future that will eventually hold the result of that function call.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
。的行为一样async(std::launch::async | std::launch::deferred, f, args...)。换句话说，f可以开始在一个新的线程，或者它也可以同步运行的一个值被查询时，所得到的std::future.
Original:
Behaves the same as async(std::launch::async | std::launch::deferred, f, args...). In other words, f may be started in a new thread or it may be run synchronously when the resulting std::future is queried for a value.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
。带参数的调用一个函数fargs根据具体的上市政策policy。
Original:
Calls a function f with arguments args according to a specific launch policy policy:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
  • 。如果“异步”标志的设置（即policy & std::launch::async != 0），然后async产生一个新的线程执行，如果由std::thread(f, args...)，但如果功能f返回一个值或抛出一个异常，它被存储在共享状态访问通过std::futureasync返回给调用者.
    Original:
    If the async flag is set (i.e. policy & std::launch::async != 0), then async spawns a new thread of execution as if by std::thread(f, args...), except that if the function f returns a value or throws an exception, it is stored in the shared state accessible through the std::future that async returns to the caller.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • 。如果“递延”标志（即policy & std::launch::deferred != 0），然后async皈依args...相同的方式std::thread构造函数，但不会产生一个新的线程执行。相反，“懒惰的评价”：在第一次调用一个不定时等功能的std::futureasync返回给调用者会导致f(args...)在当前线程中执行。所有其他的访问相同的std::future将立即返回结果.
    Original:
    If the deferred flag is set (i.e. policy & std::launch::deferred != 0), then async converts args... the same way as by std::thread constructor, but does not spawn a new thread of execution. Instead, lazy evaluation is performed: the first call to a non-timed wait function on the std::future that async returned to the caller will cause f(args...) to be executed in the current thread. All further accesses to the same std::future will return the result immediately.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

目录

[编辑] 。参数。

f -
。到调用函数或函数对象。
Original:
function or function object to call
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
args... -
。参数传递给f。
Original:
parameters to pass to f
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
policy -
。位掩码值，其中个别的位控制在允许的执行方法
Bit
。解释。
Original:
Explanation
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
std::launch::async
。启用异步的评价。
Original:
enable asynchronous evaluation
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
std::launch::deferred
。使懒惰的评估。
Original:
enable lazy evaluation
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
。
Original:
bitmask value, where individual bits control the allowed methods of execution
Bit
。解释。
Original:
Explanation
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
std::launch::async
。启用异步的评价。
Original:
enable asynchronous evaluation
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
std::launch::deferred
。使懒惰的评估。
Original:
enable lazy evaluation
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

===。 返回值。===

。 std::future指的是该函数的返回值.
Original:
std::future referring to the return value of the function.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[编辑] 。例外。

。抛出std::system_error如果发射的政策是std::errc::resource_unavailable_try_again和实施是无法启动一个新线程的错误条件std::launch::async.
Original:
Throws std::system_error with error condition std::errc::resource_unavailable_try_again if the launch policy is std::launch::async and the implementation is unable to start a new thread.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[编辑] 。注释。

。使额外的（实现定义的）位在默认启动的政策的实施可能会延长std::async第一个重载的行为.
Original:
The implementation may extend the behavior of the first overload of std::async by enabling additional (implementation-defined) bits in the default launch policy.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[编辑] 。为例。

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <future>
 
template <typename RAIter>
int parallel_sum(RAIter beg, RAIter end)
{
    typename RAIter::difference_type len = end-beg;
    if(len < 1000)
        return std::accumulate(beg, end, 0);
 
    RAIter mid = beg + len/2;
    auto handle = std::async(std::launch::async,
                              parallel_sum<RAIter>, mid, end);
    int sum = parallel_sum(beg, mid);
    return sum + handle.get();
}
 
int main()
{
    std::vector<int> v(10000, 1);
    std::cout << "The sum is " << parallel_sum(v.begin(), v.end()) << '\n';
}

Output: 

The sum is 10000
来自“http://zh.cppreference.com/mwiki/index.php?title=cpp/thread/async&oldid=28679”