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 se comporta como si invoca el objeto invocable en un nuevo subproceso. Esto significa que, aunque normalmente resulta en la creación de un nuevo subproceso, la implementación puede usar otros mecanismos para lograr un comportamiento equivalente. Sin embargo, la implementación de Microsoft actualmente no se ajusta estrictamente a este comportamiento. Obtiene sus subprocesos de Windows ThreadPool, que puede proporcionar un subproceso reciclado en lugar de uno nuevo. Esto significa que la launch::async
directiva se implementa eficazmente 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 evitar el uso de variables locales de subprocesos 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.