std::async(std::launch::async, f, args...) ejecuta f en otro hilo y devuelve un std::future para su resultado. future.get() espera a que el resultado esté listo y lo devuelve, una sola vez. Si f lanzó, get() lanza la misma excepción en quien llama, así que los errores pasan de un hilo a otro sin código adicional.
Arranca todo antes de esperar nada: async(a).get(); async(b).get(); ejecuta a y b uno detrás de otro. La política de lanzamiento también importa: std::launch::deferred ejecuta la función de forma perezosa dentro de get(), en el hilo que llama.
Cuando el resultado viene de un hilo que gestionas tú, una std::promise es el extremo que envía: set_value o set_exception, exactamente una vez. Una promesa que se destruye sin ninguno de los dos hace que get() lance std::future_error ("promesa rota"). Repartir el trabajo (una tarea por trozo y después sumar los futures) es el patrón diario para procesar lotes en paralelo.
Aquí los hilos son simulados. Tu programa se ejecuta en un solo hilo real mientras un planificador alterna entre tus hilos en las lecturas y escrituras compartidas, los bloqueos, las operaciones atómicas, las esperas, los yield y las pausas, y cada prueba se ejecuta con 12 planificaciones distintas. El orden en que pueden pasar las cosas, las carreras en esos puntos y los interbloqueos son fieles. La aceleración paralela real y los efectos de los órdenes de memoria débiles, no.
Arranca primero todas las tareas y después recoge los resultados.