移动语义在异步编程中的应用

异步编程，说白了就是让程序能同时干多件事。C++11 引入的 std::future 和 std::promise 就是干这个的。但很多人写异步代码时，会忽略移动语义的重要性。我见过不少项目，明明可以用移动语义大幅提升性能，结果却因为拷贝导致内存暴涨。

今天我们就聊聊，移动语义在异步编程中到底怎么用。

std::promise 与移动语义

std::promise 是一个承诺——它承诺将来某个时刻会提供一个值。这个值通过 set_value 传递。但注意，set_value 接受的是左值引用还是右值引用？

看源码：

// 伪代码示意
void set_value(const T& value);  // 拷贝版本
void set_value(T&& value);       // 移动版本

没错，它有两个重载。如果你传一个临时对象，它会调用移动版本。如果你传一个左值，它会调用拷贝版本。

我个人习惯是：如果数据不再需要，就显式用 std::move 把它移进去。

std::promise<std::vector<int>> prom;
std::vector<int> data = {1, 2, 3, 4, 5};

// 不好的做法：拷贝
prom.set_value(data);  // data 被拷贝，原数据还在

// 好的做法：移动
prom.set_value(std::move(data));  // data 被清空，零拷贝

你想想看，如果 data 有 100 万个元素，拷贝一次就是 O(n) 的开销。移动只是改几个指针，O(1) 搞定。

std::future 与移动语义

std::future 本身也是可移动的。它内部持有共享状态，拷贝会复制共享状态的所有权。但 std::future 不支持拷贝构造——它只能移动。

std::future<int> fut1 = std::async([] { return 42; });

// 错误：future 不可拷贝
// std::future<int> fut2 = fut1;

// 正确：移动
std::future<int> fut2 = std::move(fut1);

为什么不能拷贝？因为每个 future 只能调用一次 get()。如果允许多个拷贝，那谁该拥有调用 get() 的权利？所以标准库直接禁止拷贝，只允许移动。

我在项目中遇到过一个问题：有人把 future 存在 std::vector 里，然后想遍历调用 get()。结果编译报错，因为 vector 要求元素可拷贝。解决方案很简单——用 std::vector<std::shared_future<T>> 代替。

异步任务中的移动捕获

用 std::async 或 std::packaged_task 时，经常需要捕获一些大对象。比如一个 std::vector 或 std::string。如果按值捕获，就是拷贝。如果按引用捕获，又可能悬空。

正确的做法是：用移动捕获。

std::vector<int> big_data = get_big_data();

// 错误：拷贝
auto fut = std::async([big_data] { 
    return process(big_data); 
});

// 正确：移动（C++14 起支持）
auto fut = std::async([data = std::move(big_data)] {
    return process(data);
});

这里用了 C++14 的初始化捕获。把 big_data 移进 lambda 里，lambda 内部持有的是移动后的数据，零拷贝。

我曾经在写一个日志系统时，需要把大量字符串异步写入文件。如果不移动，每次异步写都会拷贝整个字符串，内存占用直接翻倍。改成移动后，性能提升了一个数量级。

std::packaged_task 与移动

std::packaged_task 包装一个可调用对象，并关联一个 future。它本身也是可移动的。

std::packaged_task<int()> task([] { return 42; });
std::future<int> fut = task.get_future();

// 移动 task 到线程中执行
std::thread t(std::move(task), ...);
t.join();

int result = fut.get();

注意：packaged_task 只能移动，不能拷贝。因为每个 packaged_task 只能调用一次 operator()。

我见过有人试图把 packaged_task 放进 std::function 里，结果编译失败。因为 std::function 要求可拷贝。解决方案是用 std::move 包装，或者直接用 lambda 捕获 packaged_task 的移动版本。

异步编程中的移动语义流程图

下面这张图展示了异步编程中移动语义的核心流程：

实际案例：异步日志系统

我参与过一个游戏服务器项目，日志量很大。最初的设计是同步写日志，结果高并发时 IO 成了瓶颈。后来改成异步写，但遇到了拷贝问题。

原始代码：

// 不好的设计：每次异步写都拷贝字符串
void log(const std::string& msg) {
    auto fut = std::async([msg] {  // 拷贝 msg
        write_to_file(msg);
    });
    fut.get();  // 等待完成
}

这里每次调用 log 都会拷贝整个字符串。如果日志消息很长（比如 JSON 序列化结果），拷贝开销很大。

改进后：

// 好的设计：移动字符串
void log(std::string msg) {  // 按值传参，调用者可以移动
    auto fut = std::async([msg = std::move(msg)] {  // 移动捕获
        write_to_file(msg);
    });
    fut.detach();  // 不等待，异步执行
}

// 调用方
std::string large_msg = build_large_message();
log(std::move(large_msg));  // 零拷贝

这里用了两个移动：

• 调用方用 std::move 把字符串移进函数参数
• lambda 用初始化捕获把字符串移进闭包

整个过程中，字符串只被移动了两次，没有一次拷贝。性能提升非常明显。

嗯，这些经验都是我在实际项目中踩过坑才总结出来的。你想想看，如果每次异步调用都拷贝一份数据，那内存和 CPU 都扛不住。移动语义就是解决这个问题的利器。

---