Conceptos básicos de std::async y std::future
Ejecute tareas de forma asíncrona y recupere sus resultados mediante std::future.
Conceptos básicos de std::async y std::future es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.
Tareas asíncronas
std::async ejecuta una función de forma asíncrona y devuelve un std::future que proporciona el resultado. Es una alternativa de más alto nivel a la gestión manual de hilos.
Uso básico
Pase una función invocable y sus argumentos. std::async devuelve un std::future<Result>.
#include <future>
int compute() { return 42; }
std::future<int> f = std::async(compute);
int result = f.get(); // blocks until donePolíticas de lanzamiento
El primer argumento controla cuándo se ejecuta la tarea:
std::launch::async— inicia un hilo nuevo inmediatamentestd::launch::deferred— se ejecuta de forma síncrona al llamar a get()- Predeterminada (sin política) — la implementación elige
auto f = std::async(std::launch::async, compute);Métodos de std::future
Operaciones habituales:
get()— bloquea hasta que termina y devuelve el resultado (solo una vez)wait()— bloquea, pero no devuelve el resultadowait_for(d)/wait_until(t)— esperas temporizadasvalid()— ¿se ha configurado este future?
Propagación de excepciones
Si la tarea asíncrona lanza una excepción, esta se almacena en el future y se vuelve a lanzar al llamar a get().
auto f = std::async([] { throw std::runtime_error("oops"); });
try {
f.get();
} catch (const std::exception& e) {
std::cout << e.what();
}Devolver varios valores
Envuelva el resultado en una tupla, una estructura o un contenedor.
auto f = std::async([] {
return std::make_pair(42, std::string("hello"));
});
auto [n, s] = f.get();Varias tareas en paralelo
Inicie varias tareas asíncronas y espere a que todas terminen.
auto a = std::async(work_a);
auto b = std::async(work_b);
auto c = std::async(work_c);
std::cout << a.get() + b.get() + c.get();std::promise: future manual
En patrones productor-consumidor en los que el consumidor necesita un future, pero el productor está en otro hilo, utilice std::promise.
std::promise<int> p;
std::future<int> f = p.get_future();
std::thread t([&p] { p.set_value(42); });
std::cout << f.get();
t.join();std::packaged_task
Asocia una función invocable con un future. Resulta útil cuando la tarea se invoca en otro lugar, como un grupo de hilos.
shared_future
Un std::future solo puede leerse una vez. std::shared_future permite varios lectores, lo que resulta útil para difundir un resultado.
Comportamiento del destructor
El destructor de un future devuelto por std::async con la política predeterminada puede bloquearse hasta que termine la tarea. Téngalo en cuenta en tareas de larga duración.
Más allá de std::async
Para una asincronía apta para producción, considere bibliotecas como Boost.Asio, Folly o los ejecutores y las corrutinas de C++20/23. std::async es un punto de partida.
Comprobación rápida
¿Qué hace llamar a .get() sobre un std::future?
Resumen
std::async ejecuta una función de forma asíncrona; el std::future devuelto proporciona el resultado y propaga las excepciones. Utilice políticas de lanzamiento para controlar la ejecución. Para patrones complejos, utilice std::promise y std::packaged_task.
Aprende C++ con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 51
- Lecciones
- 203
Preguntas frecuentes
¿La lección «Conceptos básicos de std::async y std::future» es gratis?
Sí — el texto completo de «Conceptos básicos de std::async y std::future» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Conceptos básicos de std::async y std::future»?
Ejecute tareas de forma asíncrona y recupere sus resultados mediante std::future. Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C++ Academy?
No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Conceptos básicos de std::async y std::future»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C++ Academy?
Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Unión y separación de std::thread
- std::mutex, lock_guard y unique_lock
- Variables de condición y patrones de trabajadores
- Conceptos básicos de std::async y std::future