Пространства имён
Варианты
Действия

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)
Generic управления замком
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)
Futures
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)
 
Заголовочный файл <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)
async шаблон функции выполняет функцию f асинхронно (возможно, в отдельном потоке) и возвращает 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)
Вызывает функцию f с аргументами args в соответствии с определенной политикой запуск 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::future, что async возвращается к вызывающему.
    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::future, что async возвращается вызывающему вызовет 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.
  • Если оба std::launch::async и std::launch::deferred флаги установлены в policy, это до реализации, выполнять ли асинхронное выполнение или ленивые вычисления.
    Original:
    If both the std::launch::async and std::launch::deferred flags are set in policy, it is up to the implementation whether to perform asynchronous execution or lazy evaluation.
    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.

[править] Notes

Реализация может расширять поведение первой перегрузки 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';
}

Вывод: 

The sum is 10000
Источник — «http://ru.cppreference.com/mwiki/index.php?title=cpp/thread/async&oldid=31340»