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
policy
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 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. Otra implicación de la implementación basada en ThreadPool es que no hay ninguna garantía de que las variables locales del subproceso se destruyen cuando se completa el subproceso. Si el subproceso se recicla y se proporciona a una nueva llamada a async, las variables antiguas siguen 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 notimed que espere a que el estado asincrónico asociado esté listo en vigor llama a la función diferida mediante la evaluación INVOKE(dfn, dargs..., Ty)de .
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 una o el valor que devuelve 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ífico de Microsoft
Cuando la función pasada se ejecuta de forma asincrónica, se ejecuta en el grupo de subprocesos de Windows. Para obtener más información, consulte Grupos de subprocesos. El número de subprocesos simultáneos se limita al valor predeterminado del grupo de subprocesos, que es 500 subprocesos.
Antes de Windows 11 y Windows Server 2022, las aplicaciones estaban limitadas de forma predeterminada a un único grupo de procesadores que tenía como máximo 64 procesadores lógicos. Esto limita el número de subprocesos que se ejecutan simultáneamente a 64. Para obtener más información, consulte Grupos de procesadores.
A partir de Windows 11 y Windows Server 2022, los procesos y sus subprocesos tienen afinidades de procesador que, de forma predeterminada, abarcan todos los procesadores del sistema y en varios grupos de máquinas con más de 64 procesadores. El límite del número de subprocesos simultáneos es ahora el número total de procesadores lógicos del sistema.
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 un objeto error_condition junto con el error_category objeto que caracteriza los future errores.
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.