Функции пространства имен concurrency

Статья
06/16/2023

Alloc

Выделяет блок памяти указанного размера из подраспределителя кэширования среды параллелизма.

void* __cdecl Alloc(size_t _NumBytes);

Параметры

_NumBytes
Количество байтов памяти для выделения.

Возвращаемое значение

Указатель на только что выделенную память.

Замечания

Дополнительные сведения о том, какие сценарии в приложении могут воспользоваться подлокатором кэширования, см. в разделе Планировщик задач.

asend

Асинхронная операция отправки, которая планирует задачу для распространения данных в целевой блок.

template <class T>
bool asend(
    _Inout_ ITarget<T>* _Trg,
    const T& _Data);

template <class T>
bool asend(
    ITarget<T>& _Trg,
    const T& _Data);

Параметры

T
Тип отправленных данных.

_Trg
Указатель или ссылка на целевой объект, к которому отправляются данные.

_Данных
Ссылка на отправленные данные.

Возвращаемое значение

true Значение , если сообщение было принято до возврата метода, false в противном случае.

Замечания

Дополнительные сведения см. в разделе "Функции передачи сообщений".

cancel_current_task

Отменяет выполняющуюся в данный момент задачу. Эту функцию можно вызывать из тела задачи, чтобы прервать выполнение задачи и перевести ее в состояние canceled.

Вызов этой функции является неподдерживаемым сценарием, если вы не находитесь в теле task. Это приведет к неопределенному поведению, например сбою или неответственности в приложении.

inline __declspec(noreturn) void __cdecl cancel_current_task();

clear

Очищает параллельную очередь, уничтожая все элементы, которые в настоящее время закребованы. Этот метод не является безопасным для параллелизма.

template<typename T, class _Ax>
void concurrent_queue<T, _Ax>::clear();

Параметры

_Ax

create_async

Создает асинхронную конструкцию среды выполнения Windows на основе предоставленного пользователем лямбда-выражения или объекта функции. Тип возвращаемого значения create_async — один из следующих: IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^ или IAsyncOperationWithProgress<TResult, TProgress>^, в зависимости от сигнатуры лямбда-выражения, переданного методу.

template<typename _Function>
__declspec(noinline) auto create_async(const _Function& _Func)
    -> decltype(ref new details::_AsyncTaskGeneratorThunk<_Function>(_Func));

Параметры

_Функции
Тип.

_Func
Лямбда-выражение или объект функции, из которого требуется создать асинхронную конструкцию среды выполнения Windows.

Возвращаемое значение

Асинхронная конструкция, представленная IAsyncAction^, IAsyncActionWithProgress<>^, IAsyncOperation TResult^, или IAsyncOperationWithProgress<<TResult>, TProgres>^. Возвращаемый интерфейс зависит от сигнатуры лямбда-выражения, переданного функции.

Замечания

Возвращаемый тип лямбда-выражения определяет, чем является конструкция — действием или операцией.

Лямбда-выражения, возвращающие значение void, приводят к созданию действий. Лямбда-выражения, возвращающие результат типа TResult, приводят к созданию операций TResult.

Лямбда-выражение может также возвращать объект task<TResult>, который инкапсулирует асинхронную работу внутри себя или является продолжением цепочки задач, представляющих асинхронную работу. В этом случае лямбда-выражение само выполняется встроенным образом, поскольку задачами являются те, которые выполняются асинхронно, и возвращаемый тип лямбда-выражения распаковывается для создания асинхронной конструкции, возвращаемой create_async. Это означает, что лямбда,возвращающая пустоту> задачи<, приведет к созданию действий, а лямбда-лямбда,возвращающая задачу<TResult, приведет к созданию операций TResult>.

Лямбда-выражение может принимать ноль, один или два аргумента. Допустимые аргументы — progress_reporter<TProgress> и cancellation_token, в этом порядке, если используются оба. Лямбда-выражение без аргументов вызывает создание асинхронной конструкции без возможности выдачи отчета о ходе выполнения. Лямбда-код, который принимает progress_reporter<TProgress,> приведет create_async к возврату асинхронной конструкции, которая сообщает ход выполнения типа TProgress каждый раз, когда report вызывается метод объекта progress_reporter. Лямбда-выражение, которое принимает cancellation_token, может использовать этот токен для проверки отмены или передать создаваемым им задачам, чтобы отмена асинхронной конструкции приводила к отмене этих задач.

Если тело лямбда-объекта или функции возвращает результат (а не задача<TResult>), lamdba будет выполняться асинхронно в рамках процесса MTA в контексте задачи, для неявно создается для нее среда выполнения. Метод IAsyncInfo::Cancel вызовет отмену неявной задачи.

Если тело лямбда-выражения возвращает задачу, лямбда-выражение выполняется встроенным образом, и путем объявления, чтобы лямбда-выражение принимало аргумент типа cancellation_token, можно привести в действие отмену всех задач, создаваемых внутри лямбда-выражения путем передачи этого токена при их создании. Можно также использовать метод register_callback для этого токена, чтобы вызвать выполнение исполняющей средой обратного вызова при вызове IAsyncInfo::Cancel для созданной асинхронной операции или действия.

Эта функция доступна только для среда выполнения Windows приложений.

CreateResourceManager

Возвращает интерфейс, который представляет одноэлементный экземпляр диспетчера ресурсов среды выполнения с параллелизмом. Диспетчер ресурсов отвечает за назначение ресурсов планировщикам, которым требуется взаимодействовать друг с другом.

IResourceManager* __cdecl CreateResourceManager();

Возвращаемое значение

Интерфейс IResourceManager.

Замечания

Несколько последующих вызовов этого метода возвращают один и тот же экземпляр Resource Manager. Каждый вызов метода увеличивает количество ссылок в Resource Manager и должен соответствовать вызову метода IResourceManager::Release при завершении взаимодействия планировщика с Resource Manager.

unsupported_os возникает, если операционная система не поддерживается средой выполнения параллелизма.

create_task

Создает объект задачи PPL. Функция create_task может использоваться в любой ситуации, где бы вы использовали конструктор задач. Она предоставлена главным образом для удобства, поскольку позволяет использовать ключевое слово auto при создании задач.

template<typename T>
__declspec(noinline) auto create_task(T _Param, const task_options& _TaskOptions = task_options())
    -> task<typename details::_TaskTypeFromParam<T>::T>;

template<typename _ReturnType>
__declspec( noinline) task<_ReturnType> create_task(const task<_ReturnType>& _Task);

Параметры

T
Тип параметра, из которого будет создаваться задача.

_Returntype
Тип.

_Param
Параметр, из которого будет создаваться задача. Это может быть лямбда-объект или объект-функция, объект, task_completion_event другой task объект или интерфейс Windows::Foundation::IAsyncInfo, если вы используете задачи в приложении UWP.

_TaskOptions
Параметры задачи.

_Задача
Задача, которую требуется создать.

Возвращаемое значение

Новая задача типа T, которая выводится из _Param.

Замечания

Первая перегрузка ведет себя как конструктор задач, принимаюющий один параметр.

Вторая перегрузка связывает маркер отмены, предоставленный только что созданной задачей. Если вы используете эту перегрузку, вы не можете передать другой task объект в качестве первого параметра.

Тип возвращаемой задачи выводится из первого параметра функции. Если _Param это , или task<T>functor, который возвращает тип T или task<T>тип созданной задачиtask<T>task_completion_event<T>.

В приложении UWP, если _Param тип Windows::Foundation::IAsyncOperation T>^ или Windows::Foundation::IAsyncOperationWithProgress<<T, P>^или functor, возвращающий любой из этих типов, созданная задача будет иметь типtask<T>. Если _Param имеет тип Windows::Foundation::IAsyncAction^ или Windows::Foundation::IAsyncActionWithProgress<P>^, или functor, который возвращает любой из этих типов, созданная задача будет иметь тип task<void>.

DisableTracing

Отключает трассировку в среде выполнения с параллелизмом. Эту функция не рекомендуется использовать, поскольку трассировка событий Windows по умолчанию не регистрируется.

__declspec(deprecated("Concurrency::DisableTracing is a deprecated function.")) _CRTIMP HRESULT __cdecl DisableTracing();

Возвращаемое значение

Если трассировка была правильно отключена, S_OK возвращается. Если трассировка не была запущена ранее, возвращается E_NOT_STARTED

EnableTracing

Включает трассировку в среде выполнения с параллелизмом. Эта функция не рекомендована к использованию, поскольку трассировка событий Windows теперь по умолчанию включена.

__declspec(deprecated("Concurrency::EnableTracing is a deprecated function.")) _CRTIMP HRESULT __cdecl EnableTracing();

Возвращаемое значение

Если трассировка была правильно инициирована, S_OK возвращается; в противном случае E_NOT_STARTED возвращается.

Бесплатно

Освобождает блок памяти, ранее выделенный методом Alloc для подраспределителя кэширования среды выполнения с параллелизмом.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

Параметры

_PAllocation
Указатель на память, выделенную ранее методом Alloc , который должен быть освобожден. Если для параметра _PAllocation задано значение NULL, этот метод будет игнорировать его и немедленно возвращать.

Замечания

get_ambient_scheduler

inline std::shared_ptr<::Concurrency::scheduler_interface> get_ambient_scheduler();

Возвращаемое значение

GetExecutionContextId

Возвращает уникальный идентификатор, который можно назначить контексту выполнения, реализующему интерфейс IExecutionContext.

unsigned int __cdecl GetExecutionContextId();

Возвращаемое значение

Уникальный идентификатор контекста выполнения.

Замечания

Используйте этот метод для получения идентификатора контекста выполнения перед передачей IExecutionContext интерфейса в качестве параметра любому из методов, предлагаемых Resource Manager.

GetOSVersion

Возвращает версию операционной системы.

IResourceManager::OSVersion __cdecl GetOSVersion();

Возвращаемое значение

Перечисленное значение, представляющее операционную систему.

Замечания

unsupported_os возникает, если операционная система не поддерживается средой выполнения параллелизма.

GetProcessorCount

Возвращает число аппаратных потоков базовой системы.

unsigned int __cdecl GetProcessorCount();

Возвращаемое значение

Количество аппаратных потоков.

Замечания

unsupported_os возникает, если операционная система не поддерживается средой выполнения параллелизма.

GetProcessorNodeCount

Возвращает число узлов NUMA или пакетов процессора в базовой системе.

unsigned int __cdecl GetProcessorNodeCount();

Возвращаемое значение

Количество узлов NUMA или пакетов процессора.

Замечания

Если система содержит больше узлов NUMA, чем пакеты процессора, возвращается число узлов NUMA, в противном случае возвращается количество пакетов процессора.

unsupported_os возникает, если операционная система не поддерживается средой выполнения параллелизма.

GetSchedulerId

Возвращает уникальный идентификатор, который можно назначить планировщику, реализующему интерфейс IScheduler.

unsigned int __cdecl GetSchedulerId();

Возвращаемое значение

Уникальный идентификатор планировщика.

Замечания

Используйте этот метод для получения идентификатора планировщика перед передачей IScheduler интерфейса в качестве параметра любому из методов, предлагаемых Resource Manager.

internal_assign_iterators

template<typename T, class _Ax>
template<class _I>
void concurrent_vector<T, _Ax>::internal_assign_iterators(
   _I first,
   _I last);

Параметры

_Ax

first

last

interruption_point

Создает точку прерывания для отмены. Если отмена выполняется в контексте, где вызывается эта функция, это создает внутреннее исключение, которое прерывает текущую выполняемую параллельную работу. Если отмена не выполняется, функция ничего не делает.

inline void interruption_point();

Замечания

Не следует перехватывать внутреннее исключение отмены, создаваемое функцией interruption_point(). Исключение будет перехвачено и обработано средой выполнения, и его перехват может вызвать непредсказуемое поведение программы.

is_current_task_group_canceling

Возвращает значение, указывающее, находится ли группа задач, которая в данный момент выполняется в текущем контексте во встроенном режиме, в процессе активной отмены (или вскоре перейдет в это состояние). Обратите внимание, что в отсутствие групп задач, выполняющихся в текущем контексте во встроенном режиме, будет возвращено значение false.

bool __cdecl is_current_task_group_canceling();

Возвращаемое значение

true Значение , если группа задач, которая выполняется в данный момент, отменяется, false в противном случае.

Замечания

Дополнительные сведения см. в разделе "Отмена".

make_choice

Конструирует блок сообщений choice из необязательного объекта Scheduler или ScheduleGroup и двух или более источников входных данных.

template<typename T1, typename T2, typename... Ts>
choice<std::tuple<T1, T2, Ts...>> make_choice(
    Scheduler& _PScheduler,
    T1  _Item1,
    T2  _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
choice<std::tuple<T1, T2, Ts...>> make_choice(
    ScheduleGroup& _PScheduleGroup,
    T1  _Item1,
    T2  _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
choice<std::tuple<T1, T2, Ts...>> make_choice(
    T1  _Item1,
    T2  _Item2,
    Ts... _Items);

Параметры

T1
Тип блока сообщений первого источника.

T2
Тип блока сообщений второго источника.

_PScheduler
Объект Scheduler , в котором запланирована задача распространения для блока обмена сообщениями choice .

_Item1
Первый источник.

_Item2
Второй источник.

_Элементы
Дополнительные источники.

_PScheduleGroup
Объект ScheduleGroup , в котором запланирована задача распространения для блока обмена сообщениями choice . Используемый объект Scheduler подразумевается группой расписаний.

Возвращаемое значение

Блок сообщений choice с двумя или более источниками входных данных.

make_greedy_join

Конструирует блок сообщений greedy multitype_join из необязательного объекта Scheduler или ScheduleGroup и двух или более источников входных данных.

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>,greedy> make_greedy_join(
    Scheduler& _PScheduler,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>, greedy> make_greedy_join(
    ScheduleGroup& _PScheduleGroup,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>, greedy> make_greedy_join(
    T1 _Item1,
    T2 _Items,
    Ts... _Items);

Параметры

T1
Тип блока сообщений первого источника.

T2
Тип блока сообщений второго источника.

_PScheduler
Объект Scheduler , в котором запланирована задача распространения для блока обмена сообщениями multitype_join .

_Item1
Первый источник.

_Item2
Второй источник.

_Элементы
Дополнительные источники.

_PScheduleGroup
Объект ScheduleGroup , в котором запланирована задача распространения для блока обмена сообщениями multitype_join . Используемый объект Scheduler подразумевается группой расписаний.

Возвращаемое значение

Блок сообщений greedy multitype_join с двумя или более источниками входных данных.

make_join

Конструирует блок сообщений non_greedy multitype_join из необязательного объекта Scheduler или ScheduleGroup и двух или более источников входных данных.

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>>
    make_join(
Scheduler& _PScheduler,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>> make_join(
ScheduleGroup& _PScheduleGroup,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>> make_join(
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

Параметры

T1
Тип блока сообщений первого источника.

T2
Тип блока сообщений второго источника.

_Item1
Первый источник.

_Item2
Второй источник.

_Элементы
Дополнительные источники.

Возвращаемое значение

Блок сообщений non_greedy multitype_join с двумя или более источниками входных данных.

make_task

Метод фабрики для создания объекта task_handle.

template <class _Function>
task_handle<_Function> make_task(const _Function& _Func);

Параметры

_Функции
Тип объекта функции, который будет вызван для выполнения работы, представленной task_handle объектом.

_Func
Функция, которая будет вызвана для выполнения работы, представленной task_handle объектом. Это может быть лямбда-functor, указатель на функцию или любой объект, поддерживающий версию оператора вызова функции с подписью void operator()().

Возвращаемое значение

Объект task_handle.

Замечания

Эта функция полезна, если необходимо создать объект с лямбда-выражением, так как он позволяет создавать task_handle объект без знания истинного типа лямбда-functor.

parallel_buffered_sort

Упорядочивает элементы в указанном диапазоне в порядке, отличном от убыванию, или в соответствии с критерием упорядочивания, заданным двоичным предикатом, параллельно. Эта функция семантически аналогична std::sort в том, что она является нестабильной сортировкой на месте на основе сравнения, за исключением того, что ей требуется O(n) дополнительного пространства и инициализация по умолчанию для сортируемых элементов.

template<typename _Random_iterator>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator,
    typename _Random_iterator>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator,
    typename _Random_iterator>
inline void parallel_buffered_sort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Random_iterator,
    typename _Function>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

template<typename _Allocator,
    typename _Random_iterator,
    typename _Function>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

template<typename _Allocator,
    typename _Random_iterator,
    typename _Function>
inline void parallel_buffered_sort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

Параметры

_Random_iterator
Тип итератора входного диапазона.

_Распределителя
Тип стандартной библиотеки C++, совместимой с памятью.

_Функции
Тип двоичного компратора.

_Начать
Итератор произвольного доступа, обращающийся к позиции первого элемента в сортируемом диапазоне.

_Конец
Итератор произвольного доступа, обращающийся к позиции после последнего элемента в сортируемом диапазоне.

_Alloc
Экземпляр стандартной библиотеки C++, совместимый с памятью.

_Func
Определяемый пользователем объект функции предиката, который определяет критерии сравнения, которые должны соблюдаться идущими подряд элементами при упорядочении. Бинарный предикат принимает два аргумента и возвращает true в случае соответствия и false в случае несоответствия. Эта функция средства сравнения должна задать строгое слабое упорядочение пар элементов последовательности.

_Chunk_size
Минимальный размер блока, который будет разбит на два для параллельного выполнения.

Замечания

Для всех перегрузок требуется n * sizeof(T) дополнительное пространство, где n количество элементов для сортировки и T тип элемента. В большинстве случаев parallel_buffered_sort будут отображаться улучшения производительности по сравнению с parallel_sort, и вы должны использовать его более parallel_sort, если у вас есть доступ к памяти.

Если вы не предоставляете двоичный компратор std::less , используется в качестве значения по умолчанию, для которого требуется тип элемента для предоставления оператора operator<().

Если вы не предоставляете тип или экземпляр распределителя, для выделения буфера используется распределитель std::allocator<T> памяти стандартной библиотеки C++.

Алгоритм делит входной диапазон на два блока и последовательно делит каждый блок на два подблока для параллельного выполнения. Необязательный аргумент _Chunk_size можно использовать для указания алгоритму, который должен обрабатывать блоки размера <_Chunk_size последовательно.

Parallel_for

parallel_for выполняет итерацию по диапазону индексов и выполняет предоставленную пользователем функцию в каждой итерации параллельно.

template <typename _Index_type, typename _Function, typename _Partitioner>
void parallel_for(
    _Index_type first,
    _Index_type last,
    _Index_type _Step,
    const _Function& _Func,
    _Partitioner&& _Part);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    _Index_type _Step,
    const _Function& _Func);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    const auto_partitioner& _Part = auto_partitioner());

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    const static_partitioner& _Part);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    const simple_partitioner& _Part);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    affinity_partitioner& _Part);

Параметры

_Index_type
Тип индекса, используемого для итерации.

_Функции
Тип функции, которая будет выполняться при каждой итерации.

_Разделения
Тип секционатора, который используется для секционирования заданного диапазона.

first
Первый индекс, который необходимо включить в итерацию.

last
Индекс за последним индексом, который будет включен в итерацию.

_Шаг
Значение, по которому выполняется шаг при итерации отfirst.last Шаг должен быть положительным. invalid_argument возникает, если шаг меньше 1.

_Func
Функция, выполняемая при каждой итерации. Это может быть лямбда-выражение, указатель функции или любой объект, поддерживающий версию оператора вызова функции с подписью void operator()(_Index_type).

_Часть
Ссылка на объект-разделитель. Аргумент может быть одним из constauto_partitioner&,const static_partitioner, constsimple_partitioner или affinity_partitioner&& Если используется объект affinity_partitioner&, ссылка должна быть ссылкой, отличной от const l-value, чтобы алгоритм может хранить состояние для будущих циклов для повторного использования.

Замечания

Дополнительные сведения см. в разделе "Параллельные алгоритмы".

Parallel_for_each

parallel_for_each применяет указанную функцию к каждому элементу в диапазоне параллельно. Эта функция семантически эквивалентна функции for_each в пространстве имен std, за исключением того, что итерация по элементам выполняется параллельно и порядок итерации не определен. Аргумент _Func должен поддерживать оператор вызова функции формы operator()(T), где параметр T является типом элемента контейнера, для которого выполняется итерация.

template <typename _Iterator, typename _Function>
void parallel_for_each(
    _Iterator first,
    _Iterator last,
    const _Function& _Func);

template <typename _Iterator, typename _Function, typename _Partitioner>
void parallel_for_each(
    _Iterator first,
    _Iterator last,
    const _Function& _Func,
    _Partitioner&& _Part);

Параметры

_Итератор
Тип итератора, используемого для итерации по контейнеру.

_Функции
Тип функции, которая будет применена к каждому элементу в диапазоне.

_Разделения
first
Итератор, указывающий положение первого элемента, который будет включен в параллельную итерацию.

last
Итератор, обращаюющийся к позиции, за последней элементом, который должен быть включен в параллельную итерацию.

_Func
Определяемый пользователем объект функции, применяемый к каждому элементу в диапазоне.

Замечания

auto_partitioner будет использоваться для перегрузки без явного секционатора.

Для итераторов, не поддерживающих случайный доступ, поддерживается только auto_partitioner .

Дополнительные сведения см. в разделе "Параллельные алгоритмы".

parallel_invoke

Выполняет объекты функции, предоставленные в виде параметров, в параллельном режиме и блокирует их до завершения выполнения. Каждый объект функции может быть лямбда-выражением, указателем на функцию или любым объектом, который поддерживает оператор вызова функции с подписью void operator()().

template <typename _Function1, typename _Function2>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2);

template <typename _Function1, typename _Function2, typename _Function3>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7,
    typename _Function8>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7,
    const _Function8& _Func8);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7,
    typename _Function8,
    typename _Function9>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7,
    const _Function8& _Func8,
    const _Function9& _Func9);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7,
    typename _Function8,
    typename _Function9,
    typename _Function10>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7,
    const _Function8& _Func8,
    const _Function9& _Func9,
    const _Function10& _Func10);

Параметры

_Function1
Тип первого объекта функции, выполняемого параллельно.

_Function2
Тип второго объекта функции, выполняемого параллельно.

_Function3
Тип третьего объекта функции, выполняемого параллельно.

_Function4
Тип четвертого объекта функции, выполняемого параллельно.

_Function5
Тип пятого объекта функции, выполняемого параллельно.

_Function6
Тип шестого объекта функции, выполняемого параллельно.

_Function7
Тип седьмого объекта функции, выполняемого параллельно.

_Function8
Тип восьмого объекта функции, выполняемого параллельно.

_Function9
Тип девятого объекта функции, выполняемого параллельно.

_Function10
Тип десятого объекта функции, выполняемого параллельно.

_Func1
Первый объект функции, выполняемый параллельно.

_Func2
Второй объект функции, выполняемый параллельно.

_Func3
Третий объект функции, выполняемый параллельно.

_Func4
Четвертый объект функции, выполняемый параллельно.

_Func5
Пятый объект функции, выполняемый параллельно.

_Func6
Шестой объект функции, выполняемый параллельно.

_Func7
Седьмой объект функции, выполняемый параллельно.

_Func8
Восьмой объект функции, выполняемый параллельно.

_Func9
Девятый объект функции, выполняемый параллельно.

_Func10
Десятый объект функции, выполняемый параллельно.

Замечания

Обратите внимание, что один или несколько объектов функции, предоставленных в качестве параметров, могут выполняться встроенным образом в контексте вызова.

Если один или несколько объектов функции, переданных в качестве параметров этой функции, создает исключение, среда выполнения выберет одно из таких исключений при выборе и распространении его вне вызова parallel_invoke.

Дополнительные сведения см. в разделе "Параллельные алгоритмы".

parallel_radixsort

Располагает элементы в указанном диапазоне в неубывающем порядке, используя алгоритм сортировки основания системы счисления. Это стабильная функция сортировки, для которой требуется функция проекции, способная проецировать сортируемые элементы в неподписанные ключи целочисленного типа. Для сортируемых элементов требуется инициализация по умолчанию.

template<typename _Random_iterator>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator, typename _Random_iterator>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator, typename _Random_iterator>
inline void parallel_radixsort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Random_iterator, typename _Function>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Proj_func,
    const size_t _Chunk_size = 256* 256);

template<typename _Allocator, typename _Random_iterator,
    typename _Function>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Proj_func,
    const size_t _Chunk_size = 256* 256);

template<typename _Allocator,
    typename _Random_iterator,
    typename _Function>
inline void parallel_radixsort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Proj_func,
    const size_t _Chunk_size = 256* 256);

Параметры

_Random_iterator
Тип итератора входного диапазона.

_Распределителя
Тип стандартной библиотеки C++, совместимой с памятью.

_Функции
Тип функции проекции.

_Начать
Итератор произвольного доступа, обращающийся к позиции первого элемента в сортируемом диапазоне.

_Alloc
Экземпляр стандартной библиотеки C++, совместимый с памятью.

_Proj_func
Определяемый пользователем объект функции проекции, который преобразует элемент в целочисленное значение.

_Chunk_size
Минимальный размер блока, который будет разбит на два для параллельного выполнения.

Замечания

Для всех перегрузок требуется n * sizeof(T) дополнительное пространство, где n количество элементов для сортировки и T тип элемента. Унарный фанктор проекции с сигнатурой I _Proj_func(T) требуется для возврата ключа при указании элемента, где T тип элемента и I является типом без знака целочисленного типа.

Если вы не предоставляете функцию проекции, функция проекции по умолчанию, которая просто возвращает элемент, используется для целочисленных типов. Функция не сможет компилироваться, если элемент не является целочисленным типом в отсутствие функции проекции.

Parallel_reduce

Параллельно вычисляет сумму всех элементов в указанном диапазоне путем вычисления последовательных частичных сумм или вычисляет результаты последовательных частичных сумм, полученных сходным образом с использованием указанной бинарной операции, отличной от суммирования. parallel_reduce семантически аналогичен std::accumulate, но требует, чтобы бинарная операция была ассоциативна, а также значение идентификатора вместо начального значения.

template<typename _Forward_iterator>
inline typename std::iterator_traits<_Forward_iterator>::value_type parallel_reduce(
    _Forward_iterator _Begin,
    _Forward_iterator _End,
    const typename std::iterator_traits<_Forward_iterator>::value_type& _Identity);

template<typename _Forward_iterator, typename _Sym_reduce_fun>
inline typename std::iterator_traits<_Forward_iterator>::value_type parallel_reduce(
    _Forward_iterator _Begin,
    _Forward_iterator _End,
    const typename std::iterator_traits<_Forward_iterator>::value_type& _Identity,
    _Sym_reduce_fun _Sym_fun);

template<typename _Reduce_type,
    typename _Forward_iterator,
    typename _Range_reduce_fun,
    typename _Sym_reduce_fun>
inline _Reduce_type parallel_reduce(
    _Forward_iterator _Begin,
    _Forward_iterator _End,
    const _Reduce_type& _Identity,
    const _Range_reduce_fun& _Range_fun,
    const _Sym_reduce_fun& _Sym_fun);

Параметры

_Forward_iterator
Тип итератора диапазона ввода.

_Sym_reduce_fun
Тип функции симметричной редукции. Это должен быть тип функции с сигнатурой _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type), где _Reduce_type совпадает с типом идентификатора и типом результата редукции. В третьей перегрузке он должен быть совместим с типом вывода _Range_reduce_fun.

_Reduce_type
Тип, до которого будет редуцирован ввод, который может отличаться от типа входного элемента. Возвращаемое значение и значение идентификатора будут иметь этот тип.

_Range_reduce_fun
Тип функции редукции диапазона. Это должен быть тип функции с сигнатурой _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type), _Reduce_type совпадает с типом идентификатора и типом результата редукции.

_Начать
Итератор ввода, указывающий на первый элемент в диапазоне для редукции.

_Конец
Итератор ввода, указывающий на позицию после последнего элемента в диапазоне для редукции.

_Идентичности
Значение идентификатора _Identity относится к тому же типу, что и результат редукции, а также совпадает с value_type итератора для первой и второй перегрузок. В третьей перегрузке значение идентификатора должно иметь тот же тип, что и результат редукции, но может отличаться от value_type итератора. Оно должно иметь такое соответствующее значение, чтобы оператор редукции диапазона _Range_fun, примененный к диапазону из единственного элемента типа value_type и значению идентификатора, вел себя подобно приведению типа этого значения из типа value_type в тип идентификатора.

_Sym_fun
Симметричная функция, которая будет использоваться на второй стадии редукции. Дополнительные сведения см. в примечаниях.

_Range_fun
Симметричная функция, которая будет использоваться на первой стадии редукции. Дополнительные сведения см. в примечаниях.

Возвращаемое значение

Результат редукции.

Замечания

Для выполнения параллельной редукции функция делит диапазон на блоки на основе количества работников, доступных базовому планировщику. Редукция происходит в две стадии, на первой стадии выполняется редукция в каждом блоке, на второй стадии выполняется редукция частичных результатов из каждого блока.

Первая перегрузка требует, чтобы типы итератора value_type и T были такими же, как и тип значения идентификатора и тип результата редукции. Тип элемента T должен предоставить оператор T T::operator + (T), чтобы выполнить редукцию элементов в каждом блоке. Тот же оператор используется на второй стадии.

Вторая перегрузка также требует, чтобы тип итератора value_type был таким же, как и тип значения идентификатора и тип результата редукции. Предоставленный бинарный оператор _Sym_fun используется на обеих стадиях редукции со значением идентификатора в качестве начального значения для первой стадии.

В третьей перегрузке тип значения идентификатора должен совпадать с типом результата редукции, но value_type итератора может отличаться от них. Функция редукции диапазона _Range_fun используется на первой стадии со значением идентификатора в качестве начального значения, а бинарная функция _Sym_reduce_fun применяется к промежуточным результатам на второй стадии.

parallel_sort

template<typename _Random_iterator>
inline void parallel_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Random_iterator,typename _Function>
inline void parallel_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

Параметры

_Random_iterator
Тип итератора входного диапазона.

_Функции
Тип бинарного функтора сравнения.

_Начать
Итератор произвольного доступа, обращающийся к позиции первого элемента в сортируемом диапазоне.

_Chunk_size
Минимальный размер блока, который будет разделен на два для параллельного выполнения.

Замечания

Первая перегрузка использует двоичный компратор std::less.

Вторая перегрузка использует предоставленное бинарное средство сравнения, которое должно иметь сигнатуру bool _Func(T, T), где T — тип элементов во входном диапазоне.

parallel_transform

Применяет заданный объект функции к каждому элементу в исходном диапазоне или к паре элементов из двух исходных диапазонов и параллельно копирует возвращаемые значения объекта функции в диапазон назначения. Эта функция семантически эквивалентна std::transform.

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    const auto_partitioner& _Part = auto_partitioner());

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    const static_partitioner& _Part);

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    const simple_partitioner& _Part);

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    affinity_partitioner& _Part);

template <typename _Input_iterator1,
    typename _Input_iterator2,
    typename _Output_iterator,
    typename _Binary_operator,
    typename _Partitioner>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Input_iterator2
first2,
    _Output_iterator _Result,
    const _Binary_operator& _Binary_op,
    _Partitioner&& _Part);

template <typename _Input_iterator1,
    typename _Input_iterator2,
    typename _Output_iterator,
    typename _Binary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Input_iterator2
first2,
    _Output_iterator _Result,
    const _Binary_operator& _Binary_op);

Параметры

_Input_iterator1
Тип первого или единственного итератора ввода.

_Output_iterator
Тип выходного итератора.

_Unary_operator
Тип унарного функтора, который должен выполняться для каждого элемента во входном диапазоне.

_Input_iterator2
Тип второго итератора ввода.

_Binary_operator
Тип бинарного функтора, выполняемого попарно на элементах из двух исходных диапазонов.

_Разделения
first1
Итератор ввода указывает на позицию первого элемента в первом или единственном исходном обрабатываемом диапазоне.

last1
Итератор ввода указывает на позицию, следующую за последним элементом в первом или единственном исходном обрабатываемом диапазоне.

_Результат
Итератор вывода указывает на позицию первого элемента в диапазоне назначения.

_Unary_op
Определенный пользователем объект унарной функции, который применяется к каждому элементу в исходном диапазоне.

first2
Итератор ввода указывает на позицию первого элемента во втором исходном обрабатываемом диапазоне.

_Binary_op
Определяемый пользователем объект бинарной функции, который последовательно применяется к парам элементов из двух исходных диапазонов.

Возвращаемое значение

Итератор вывода указывает на позицию после последнего элемента в диапазоне назначения, который получает выходные элементы, преобразованные объектом функции.

Замечания

auto_partitioner будет использоваться для перегрузки без явного аргумента секционатора.

Для итераторов, не поддерживающих случайный доступ, поддерживается только auto_partitioner .

Перегрузки, принимающие аргумент _Unary_op, преобразовывают диапазон ввода в диапазон вывода путем применения унарного функтора к каждому элементу в диапазоне ввода. _Unary_op должен поддерживать оператор вызова функции с сигнатурой operator()(T), где T является типом значения диапазона, в котором выполняются итерации.

Перегрузки, принимающие аргумент _Binary_op, преобразовывают два диапазона ввода в диапазон вывода путем применения бинарного функтора к одному элементу из первого диапазона ввода и к одному элементу из второго диапазона ввода. _Binary_op должен поддерживать оператор вызова функции с сигнатурой operator()(T, U), где T, U являются типами значений двух входных итераторов.

Дополнительные сведения см. в разделе "Параллельные алгоритмы".

получение

Общая реализация получения, позволяющая контексту ожидать данные строго из одного источника и фильтровать значения, которые принимаются.

template <class T>
T receive(
    _Inout_ ISource<T>* _Src,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

template <class T>
T receive(
    _Inout_ ISource<T>* _Src,
    typename ITarget<T>::filter_method const& _Filter_proc,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

template <class T>
T receive(
    ISource<T>& _Src,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

template <class T>
T receive(
    ISource<T>& _Src,
    typename ITarget<T>::filter_method const& _Filter_proc,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

Параметры

T
Тип полезных данных.

_Src
Указатель или ссылка на источник, из которого ожидаются данные.

_Времени ожидания
Максимальное время, для которого метод должен иметь данные в миллисекундах.

_Filter_proc
Функция фильтра, которая определяет, должны ли приниматься сообщения.

Возвращаемое значение

Значение из источника типа полезных данных.

Замечания

Если параметр _Timeout имеет значение, отличное от константы COOPERATIVE_TIMEOUT_INFINITE, исключение operation_timed_out возникает, если указанное время истекает до получения сообщения. Если требуется время ожидания нулевой длины, следует использовать функцию try_receive , а не вызывать receive время ожидания 0 (ноль), так как это более эффективно и не создает исключения во время ожидания.

Дополнительные сведения см. в разделе "Функции передачи сообщений".

run_with_cancellation_token

Немедленно и синхронно выполняет объект функции в контексте заданного токена отмены.

template<typename _Function>
void run_with_cancellation_token(
    const _Function& _Func,
    cancellation_token _Ct);

Параметры

_Функции
Тип объекта функции, который будет вызываться.

_Func
Объект функции, который будет выполняться. Этот объект должен поддерживать оператор вызова функции с сигнатурой (void).

_Ct
Токен отмены, который будет управлять неявной отменой объекта функции. Если требуется выполнение функции без возможности неявной отмены из-за отмены родительской группы задач, следует использовать cancellation_token::none().

Замечания

При отмене cancellation_token будут активированы все точки прерывания в объекте функции. Явный токен _Ct будет изолировать объект _Func от родительской отмены, если родитель имеет другой токен или вообще не имеет токена.

отправить

Синхронная операции отправки, которая ожидает принятия или отклонения сообщения целевым объектом.

template <class T>
bool send(_Inout_ ITarget<T>* _Trg, const T& _Data);

template <class T>
bool send(ITarget<T>& _Trg, const T& _Data);

Параметры

T
Тип полезных данных.

_Trg
Указатель или ссылка на целевой объект, к которому отправляются данные.

_Данных
Ссылка на отправленные данные.

Возвращаемое значение

true Значение , если сообщение принято, false в противном случае.

Замечания

Дополнительные сведения см. в разделе "Функции передачи сообщений".

set_ambient_scheduler

inline void set_ambient_scheduler(std::shared_ptr<::Concurrency::scheduler_interface> _Scheduler);

Параметры

_Планировщик
Планировщик окружающей среды, который нужно задать.

set_task_execution_resources

Ограничивает ресурсы выполнения, используемые внутренними рабочими потоками среды выполнения с параллелизмом, определенным набором сходства.

Этот метод можно вызывать только до создания диспетчера ресурсов или между двумя периодами существования диспетчера ресурсов. Его можно вызывать несколько раз при условии, что в момент вызова диспетчер ресурсов не существует. После задания ограничения сходства оно будет оставаться действительным до следующего допустимого вызова метода set_task_execution_resources.

Предоставленная маска сходства не обязана быть подмножеством маски сходства процесса. Сходство процесса обновляется при необходимости.

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

void __cdecl set_task_execution_resources(
    unsigned short count,
    PGROUP_AFFINITY _PGroupAffinity);

Параметры

_ProcessAffinityMask
Маска сходства, которой должны быть ограничены рабочие потоки среды выполнения с параллелизмом. Используйте этот метод в системе с более чем 64 аппаратными потоками, только если требуется ограничить среду выполнения с параллелизмом подмножеством текущей группы процессоров. Как правило, следует использовать версию метода, которая принимает массив сходств группы в качестве параметра, чтобы ограничить сходство на компьютерах с более чем 64 аппаратными потоками.

count
Количество записей GROUP_AFFINITY в массиве, заданном параметром _PGroupAffinity.

_PGroupAffinity
Массив записей GROUP_AFFINITY.

Замечания

Метод создает исключение invalid_operation , если в момент вызова диспетчер ресурсов присутствует, и исключение invalid_argument , если указанное сходство приводит к пустому набору ресурсов.

Версию метода, принимающую массив сходств группы в качестве параметра, следует использовать только в операционных системах Windows версии 7 и выше. В противном случае создается исключение invalid_operation.

Программное изменение сходства процессов после вызова этого метода не приведет к повторной оценке сходства, к которым он ограничен. Таким образом, все изменения сходства процесса необходимо сделать до вызова этого метода.

swap

Меняет местами элементы двух объектов concurrent_vector.

template<typename T, class _Ax>
inline void swap(
    concurrent_vector<T, _Ax>& _A,
    concurrent_vector<T, _Ax>& _B);

Параметры

T
Тип данных элементов, хранящихся в параллельных векторах.

_Ax
Тип распределителя параллельных векторов.

_A
Параллельный вектор, элементы которого необходимо обмениваться с элементами параллельного вектора _B.

_B
Параллельный вектор, предоставляющий элементы для замены, или вектор, элементы которого необходимо обмениваться с элементами параллельного вектора _A.

Замечания

Функция шаблона — это алгоритм, специализированный для класса concurrent_vector контейнера для выполнения функции-члена _A. concurrent_vector::swap( _B). Это экземпляры частичного упорядочивания шаблонов функций компилятором. Когда функции-шаблоны перегружаются таким образом, что соответствие шаблона и вызова функции не является уникальным, компилятор выберет наиболее специализированную версию функции-шаблона. Общая версия функции шаблона, template <class T> void swap(T&, T&)в классе алгоритма работает по назначению и является медленной операцией. Специализированная версия в каждом контейнере работает гораздо быстрее, так как она может работать с внутренним представлением класса контейнера.

Этот метод не является безопасным для параллелизма. При вызове этого метода никакие другие потоки не выполняют операции с обоими параллельными векторами.

task_from_exception

template<typename _TaskType, typename _ExType>
task<_TaskType> task_from_exception(
    _ExType _Exception,
    const task_options& _TaskOptions = task_options());

Параметры

_TaskType

_ExType

_Исключение

_TaskOptions

Возвращаемое значение

task_from_result

template<typename T>
task<T> task_from_result(
    T _Param,
    const task_options& _TaskOptions = task_options());

inline task<bool> task_from_result(ool _Param);

inline task<void> task_from_result(
    const task_options& _TaskOptions = task_options());

Параметры

_Param

_TaskOptions

Возвращаемое значение

Trace_agents_register_name

Связывает данное имя с блоком сообщений или агентом в трассировки событий Windows.

template <class T>
void Trace_agents_register_name(
    _Inout_ T* _PObject,
    _In_z_ const wchar_t* _Name);

Параметры

T
Тип объекта . Обычно это блок сообщений или агент.

_PObject
Указатель на блок сообщений или агент, который именован в трассировке.

_Имя
Имя для заданного объекта.

try_receive

Общая реализация проверки-получения, позволяющая контексту выполнять поиск данных строго из одного источника и фильтровать значения, которые принимаются. Если данные не готовы, метод вернет false.

template <class T>
bool try_receive(_Inout_ ISource<T>* _Src, T& _value);

template <class T>
bool try_receive(
    _Inout_ ISource<T>* _Src,
    T& _value,
    typename ITarget<T>::filter_method const& _Filter_proc);

template <class T>
bool try_receive(ISource<T>& _Src, T& _value);

template <class T>
bool try_receive(
    ISource<T>& _Src,
    T& _value,
    typename ITarget<T>::filter_method const& _Filter_proc);

Параметры

T
Тип полезных данных

_Src
Указатель или ссылка на источник, из которого ожидаются данные.

_Значение
Ссылка на расположение, в котором будет помещен результат.

_Filter_proc
Функция фильтра, которая определяет, должны ли приниматься сообщения.

Возвращаемое значение

bool Значение, указывающее, помещается ли полезные данные._value

Замечания

Дополнительные сведения см. в разделе "Функции передачи сообщений".

wait

Приостанавливает текущий контекст на указанный период времени.

void __cdecl wait(unsigned int _Milliseconds);

Параметры

_Миллисекунд
Число миллисекунд, на которое должен быть приостановлен текущий контекст. Если параметру _Milliseconds задано значение 0, текущий контекст должен уступить выполнение другим работоспособным контекстам перед продолжением.

Замечания

Если этот метод вызывается в контексте планировщика среды выполнения параллелизма, планировщик найдет другой контекст для запуска в базовом ресурсе. Поскольку планировщик предназначен для совместной работы по своей природе, этот контекст не может возобновиться точно после указанного числа миллисекунд. Если планировщик занят выполнением других задач, которые не уступают планировщику совместно, период ожидания может быть не ограничен.

When_all

Создает задачу, которая завершается успешно, если все задачи, предоставленные в качестве аргументов, завершаются успешно.

template <typename _Iterator>
auto when_all(
    _Iterator _Begin,
    _Iterator _End,
    const task_options& _TaskOptions = task_options()) ->
    decltype (details::_WhenAllImpl<typename std::iterator_traits<_Iterator>::value_type::result_type,
    _Iterator>::_Perform(_TaskOptions, _Begin,  _End));

Параметры

_Итератор
Тип итератора ввода.

_Начать
Позиция первого элемента в диапазоне элементов, которые будут объединены в результирующую задачу.

_Конец
Позиция первого элемента за пределами диапазона элементов, которые будут объединены в результирующую задачу.

_TaskOptions
Объект task_options.

Возвращаемое значение

Задача, которая успешно завершается, когда все входные задачи успешно завершены. Если входные задачи относятся к типу T, выводом этой функции будет task<std::vector<T>>. Если входные задачи относятся к типу void, выходная задача также будет task<void>.

Замечания

Функция when_all является функцией без блокировки, в качестве результата создающей task. В отличие от задачи::wait, это безопасно вызывать эту функцию в приложении UWP в потоке ASTA (Application STA).

Если одна из задач отменена или вызывает исключение, возвращаемая задача завершится рано, в отмененном состоянии, а исключение, если возникает, при вызове задачи::get или task::wait в этой задаче возникает исключение.

Дополнительные сведения см. в разделе "Параллелизм задач".

When_any

Создает задачу, которая завершается успешно, если любая из задач, предоставленных в качестве аргументов, завершается успешно.

template<typename _Iterator>
auto when_any(
    _Iterator _Begin,
    _Iterator _End,
    const task_options& _TaskOptions = task_options())
    -> decltype (
        details::_WhenAnyImpl<
            typename std::iterator_traits<_Iterator>::value_type::result_type,
            _Iterator>::_Perform(_TaskOptions, _Begin, _End));

template<typename _Iterator>
auto when_any(
    _Iterator _Begin,
    _Iterator _End,
    cancellation_token _CancellationToken)
       -> decltype (
           details::_WhenAnyImpl<
               typename std::iterator_traits<_Iterator>::value_type::result_type,
               _Iterator>::_Perform(_CancellationToken._GetImplValue(), _Begin, _End));

Параметры

_Итератор
Тип итератора ввода.

_Начать
Позиция первого элемента в диапазоне элементов, которые будут объединены в результирующую задачу.

_TaskOptions
_CancellationToken
Токен отмены, который контролирует отмену возвращаемой задачи. Если токен отмены отсутствует, результирующая задача получит токен отмены, который используется для выполнения задачи.

Возвращаемое значение

Задача, которая завершается успешно, если все входные задачи завершены успешно. Если входные задачи имеют тип T, выходными данными этой функции будут task<std::pair<T, size_t>>>, где первый элемент пары является результатом завершаемой задачи, а второй элемент — индексом завершенной задачи. Если входные задачи имеют тип void, выходными данными будет task<size_t>, где результат — индекс завершаемой задачи.

Замечания

Функция when_any является функцией без блокировки, в качестве результата создающей task. В отличие от задачи::wait, это безопасно вызывать эту функцию в приложении UWP в потоке ASTA (Application STA).

Дополнительные сведения см. в разделе "Параллелизм задач".

См. также

Пространство имен concurrency