funciones<future>

async
future_category
make_error_code
make_error_condition
swap|

async

Representa un proveedor asincrónico.

template <class Fn, class... ArgTypes>
future<typename result_of<Fn(ArgTypes...)>::type>
    async(Fn&& fn, ArgTypes&&... args);

template <class Fn, class... ArgTypes>
future<typename result_of<Fn(ArgTypes...)>::type>
    async(launch policy, Fn&& fn, ArgTypes&&... args);

Parámetros

Política
Valor launch.

Comentarios

Definiciones de las abreviaturas:

Abreviatura	Descripción
dfn	Resultado de llamar a decay_copy(forward<Fn>(fn)).
dargs	Resultado de las llamadas decay_copy(forward<ArgsTypes>(args...)).
Ty	El tipo de la clase result_of<Fn(ArgTypes...)>::type.

La primera función de plantilla devuelve async(launch::any, fn, args...).

La segunda función devuelve un objeto future<Ty> cuyo estado asincrónico asociado contiene un resultado junto con los valores de dfn y dargs y un objeto de subproceso para administrar un subproceso de ejecución independiente.

A menos que decay<Fn>::type sea un tipo distinto de launch, la segunda función no participa en la resolución de sobrecarga.

El estándar de C++ indica que si la directiva es launch::async, la función crea un subproceso nuevo. Sin embargo, la implementación de Microsoft no es conforme actualmente. Obtiene sus subprocesos del grupo de subprocesos de Windows, que en algunos casos puede proporcionar un subproceso reciclado en lugar de uno nuevo. Esto significa que la directiva launch::async se implementa como launch::async|launch::deferred. Otro aspecto de la implementación basada en el grupo de subprocesos es que no existe ninguna garantía de que las variables locales del subproceso se vayan a destruir cuando el subproceso se complete. Si el subproceso se recicla y se proporciona en una nueva llamada a async, las variables antiguas seguirán existiendo. Se recomienda no usar variables locales de subproceso con async.

Si policy es launch::deferred, la función marca su estado asincrónico asociado como que contiene una función aplazada y vuelve. La primera llamada a cualquier función no cronometrada que espera hasta que el estado asincrónico asociado esté listo llama a la función aplazada evaluando INVOKE(dfn, dargs..., Ty).

En todos los casos, el estado asincrónico asociado del objeto future no se establece en listo hasta que la evaluación de INVOKE(dfn, dargs..., Ty) no se completa, ya sea iniciando una excepción o volviendo normalmente. El resultado del estado asincrónico asociado es una excepción si se produjo alguna, o cualquier valor devuelto por la evaluación.

Nota:

Para un future (o el último shared_future) adjunto a una tarea iniciada con std::async, el destructor se bloquea si la tarea no se ha completado; es decir, se bloquea si este subproceso aún no ha llamado a .get() o a .wait() y la tarea todavía se está ejecutando. Si un future obtenido de std::async se desplaza fuera del ámbito local, otro código que lo utilice debe saber que su destructor se puede bloquear para que el estado compartido se convierta en listo.

La pseudofunción INVOKE se define en <functional>.

Específicos de Microsoft

Cuando la función pasada se ejecuta de forma asincrónica, se ejecuta en el grupo de subprocesos de Windows; vea Grupos de subprocesos. El número de subprocesos simultáneos se limita al valor predeterminado del grupo de subprocesos (actualmente, 500). El número de subprocesos que se ejecutan simultáneamente en el hardware está limitado actualmente por el número de procesadores lógicos que hay en el grupo de procesadores del proceso, por lo que se limita de facto a 64; vea Grupos de procesadores.

future_category

Devuelve una referencia al objeto error_category que caracteriza los errores asociados a objetos future.

const error_category& future_category() noexcept;

make_error_code

Crea un error_code junto con el objeto error_category que caracteriza los errores de future.

inline error_code make_error_code(future_errc Errno) noexcept;

Parámetros

Errno
Valor future_errc que identifica el error notificado.

Valor devuelto

error_code(static_cast<int>(Errno), future_category());

make_error_condition

Crea una error_condition junto con el objeto error_category que caracteriza los errores de future.

inline error_condition make_error_condition(future_errc Errno) noexcept;

Parámetros

Errno
Valor future_errc que identifica el error notificado.

Valor devuelto

error_condition(static_cast<int>(Errno), future_category());

swap

Intercambia el estado asincrónico asociado de un objeto promise con el de otro.

template <class Ty>
void swap(promise<Ty>& Left, promise<Ty>& Right) noexcept;

template <class Ty, class... ArgTypes>
void swap(packaged_task<Ty(ArgTypes...)>& Left, packaged_task<Ty(ArgTypes...)>& Right) noexcept;

Parámetros

Left
Objeto promise izquierdo.

Right
Objeto promise derecho.

Consulte también

<future>