C++中使用std::future多线程开发：共享数据等技术问题咨询

我正在开发一款C++多线程应用，不同线程需处理共享数据结构中的数据，计划使用std::future和std::async处理异步操作。现有简化代码如下：

#include <vector>
#include <future>

std::vector<int> shared_data;

// Some function to be executed asynchronously
void process_data(size_t start, size_t end) {
    for (size_t i = start; i < end; ++i) {
        // Do something with shared_data[i]
    }
}

int main() {
    std::future<void> fut1 = std::async(std::launch::async, process_data, 0, 10);
    std::future<void> fut2 = std::async(std::launch::async, process_data, 10, 20);

    // Other operations...

    return 0;
}

我存在以下疑问：

1. 多线程访问shared_data是否需要用std::mutex等同步原语保护？
2. 能否将std::future对象传递给其他函数或存入数据结构，有何潜在影响？
3. 如何处理process_data函数抛出并通过std::future传播的异常？
4. std::future在多线程场景下的使用最佳实践有哪些？

我尝试通过std::mutex和std::lock_guard保证共享数据线程安全，将std::future存入std::vector，并用try/catch捕获get()的异常，但不确定这些方法是否高效正确，希望获取复杂场景下的正确用法及异常处理指导。

1. 多线程访问共享数据的同步需求 #

是否需要同步取决于对shared_data的操作类型：

• 如果process_data仅读取元素，且整个异步操作期间shared_data不会被任何线程（包括主线程）修改，那么不需要同步。
• 如果存在任何写操作（比如修改元素值、添加/删除元素），或者异步执行期间有其他线程修改数据，必须用同步原语保护。

你尝试的std::mutex+std::lock_guard是正确的基础方案，但要注意锁的粒度：避免锁住整个循环，尽量只包裹对单个元素的操作代码块，减少不必要的线程阻塞。示例：

std::mutex data_mutex;

void process_data(size_t start, size_t end) {
    for (size_t i = start; i < end; ++i) {
        std::lock_guard<std::mutex> lock(data_mutex);
        // 仅在这里操作shared_data[i]
    }
}

如果是只读场景且数据不会被修改，可改用std::shared_mutex+std::shared_lock，允许多线程同时读取，提升并发效率。

2. std::future的传递与存储 #

可以将std::future传递给其他函数或存入数据结构，但有几点注意事项：

• std::future不可拷贝，只能通过移动语义传递（使用std::move）。比如存入std::vector的正确写法：

  std::vector<std::future<void>> futures;
  futures.push_back(std::move(fut1));
  

• 潜在影响：
  • 原std::future对象被移动后会进入无效状态，无法再调用get()或wait()。
  • 存储std::future的容器如果被多线程操作（添加、删除元素），需要额外的同步保护。
  • 必须确保所有std::future都被调用get()或wait()，否则std::future析构时会阻塞当前线程，直到异步任务完成，可能引发意外的性能问题。

3. 异步任务的异常处理 #

process_data抛出的异常会被std::async捕获并存储到std::future中，只有调用get()时才会重新抛出。你用try/catch捕获的思路是正确的，复杂场景下可统一处理：

for (auto& fut : futures) {
    try {
        fut.get();
    } catch (const std::exception& e) {
        // 处理标准异常，比如记录日志、标记任务失败
    } catch (...) {
        // 处理未知异常
    }
}

注意：wait()仅等待任务完成，不会触发异常传播；如果不调用get()，异常会被忽略，但std::future析构时仍会阻塞等待任务结束，这种做法不推荐，会丢失错误信息。

4. std::future多线程场景最佳实践 #

• 显式指定std::launch策略：std::async默认策略是std::launch::async | std::launch::deferred，可能延迟执行任务到get()/wait()调用时，若需强制异步执行，必须显式传std::launch::async。
• 避免悬空std::future：所有std::future都要调用get()或wait()，否则析构时的阻塞可能导致性能瓶颈或死锁。
• 用std::shared_future处理多线程等待场景：std::future只能get()一次，std::shared_future支持多线程多次get()，适合多个任务依赖同一异步结果的场景。
• 合理拆分任务粒度：像你代码中拆分数据范围的思路正确，但要根据数据量和CPU核心数调整，避免任务过多导致调度开销过大，或任务过少导致核心闲置。
• 同步原语搭配合理：若异步任务间有依赖，可结合std::condition_variable或std::packaged_task灵活控制执行时机，不要仅依赖std::future。
• 避免任务内长时间阻塞：如果任务涉及IO等待，优先用异步IO而非线程阻塞，减少线程资源浪费。

内容的提问来源于stack exchange，提问作者Ravement