std::async(std::launch::async, f, args...) runs f on another thread and returns a std::future for its result. future.get() waits until the result is ready and returns it, once. If f threw, get() throws the same exception in the caller, so errors cross threads without any extra code.
Start everything before you wait for anything: async(a).get(); async(b).get(); runs a and b one after the other. The launch policy matters too: std::launch::deferred runs the function lazily inside get(), on the calling thread.
When the result comes from a thread you manage yourself, a std::promise is the sending end: set_value or set_exception, exactly once. A promise destroyed without either makes get() throw std::future_error ("broken promise"). Fanning out (one task per slice, then summing the futures) is the everyday parallel-batch pattern.
Threads here are simulated. Your program runs on one real thread while a scheduler switches between your threads at shared reads and writes, locks, atomic operations, waits, yields and sleeps, and every test runs under 12 different schedules. The order things can happen in, races at those points and deadlocks are faithful. Real parallel speed-up and weak memory-order effects are not.
Start every task first, then collect the results.