第12章移动语义与多线程

课程目录第12章移动语义与多线程

12、移动语义与多线程：移动语义在线程间传递所有权、std::async 与移动、移动与线程安全

多线程编程里，资源所有权是个绕不开的话题。谁拥有这个对象？谁负责释放？如果多个线程同时访问，会不会出问题？

移动语义的出现，恰好给这些问题提供了一个优雅的解法。说白了，移动语义就是「把资源从一个地方搬到另一个地方，原处不留痕迹」。在线程间传递数据时，这种「不留痕迹」的特性特别有用。

12.1 线程间传递所有权：std::thread 与移动

先看一个最直接的场景——把对象移进线程函数。

#include <thread>
#include <vector>
#include <iostream>

class BigData {
public:
    BigData() { std::cout << "构造\n"; }
    BigData(const BigData&) { std::cout << "拷贝构造\n"; }
    BigData(BigData&&) noexcept { std::cout << "移动构造\n"; }
    ~BigData() { std::cout << "析构\n"; }
};

void process(BigData data) {
    // 处理数据...
}

int main() {
    BigData data;
    std::thread t(process, std::move(data));
    t.join();
    return 0;
}

输出结果：

构造
移动构造
析构
析构

注意看，这里只有一次移动构造，没有拷贝。如果 BigData 内部持有大量堆内存，拷贝的开销是灾难性的。移动语义让线程间传递变得轻量。

我的习惯：只要线程函数需要获取对象所有权，我一定用 std::move 传参。拷贝构造在这种场景下几乎总是多余的。

12.2 std::async 与移动语义

std::async 是 C++11 引入的异步任务工具。它返回一个 std::future，用来获取异步结果。这里移动语义同样扮演关键角色。

#include <future>
#include <iostream>

class Resource {
public:
    Resource() { std::cout << "Resource 构造\n"; }
    Resource(Resource&&) noexcept { std::cout << "Resource 移动\n"; }
    Resource(const Resource&) = delete;
    ~Resource() { std::cout << "Resource 析构\n"; }
};

Resource createResource() {
    Resource res;
    return res;  // NRVO 或移动
}

int main() {
    auto fut = std::async(std::launch::async, []() {
        return createResource();
    });
    
    Resource result = fut.get();  // 移动构造
    return 0;
}

这里有个细节值得注意：std::async 返回的 future 对象本身也是可移动的。你不能拷贝它，但可以移动它。这在把 future 存入容器或传递给其他函数时非常有用。

核心要点：std::async 内部通过移动语义传递返回值。如果返回值类型没有移动构造函数，会退化为拷贝。如果拷贝也被删除，编译直接报错。

12.3 移动与线程安全：一个容易被忽视的问题

嗯，这里要敲黑板了。移动操作本身不是线程安全的。

我曾经在项目里踩过这个坑。当时两个线程共享一个 std::unique_ptr，一个线程在移动它，另一个线程同时在读取。结果程序崩溃得一塌糊涂。

// 错误示范：不要这样做！
std::unique_ptr<int> ptr = std::make_unique<int>(42);

void thread1() {
    auto local = std::move(ptr);  // 移动，ptr 变空
}

void thread2() {
    if (ptr) {  // 可能读到空，也可能读到非空
        std::cout << *ptr << std::endl;  // 未定义行为！
    }
}

为什么会这样？因为移动操作不是原子的。它包含多个步骤：读取原对象状态、转移资源、修改原对象。这些步骤之间可能被其他线程打断。

避坑指南：移动语义只负责「所有权转移」，不负责「线程安全」。如果你要在多线程环境下移动对象，必须自己加锁或用原子操作保护。

12.4 安全实践：用移动语义配合锁

正确的做法是：在锁的保护下完成移动操作。

#include <mutex>
#include <memory>
#include <thread>

class ThreadSafeResource {
    std::mutex mtx;
    std::unique_ptr<int> data;
public:
    std::unique_ptr<int> extract() {
        std::lock_guard<std::mutex> lock(mtx);
        return std::move(data);  // 在锁内移动
    }
    
    void inject(std::unique_ptr<int> ptr) {
        std::lock_guard<std::mutex> lock(mtx);
        data = std::move(ptr);  // 在锁内移动
    }
};

这样设计的好处很明显：锁保护了移动操作的完整性。外部调用者拿到 unique_ptr 后，可以安全地在线程间传递，因为 unique_ptr 本身是只移动类型，不会出现多个线程同时访问同一份资源的情况。

12.5 移动语义与线程安全的关系图

下面这张图梳理了移动语义在多线程环境下的核心逻辑：

12.6 总结与个人经验

移动语义和多线程结合，核心就三句话：

用移动传所有权——避免拷贝开销，语义清晰
用锁保护移动——移动不是原子操作，多线程下需要同步
用 unique_ptr 管理生命周期——配合移动语义，资源管理变得简单

我记得有一次重构一个多线程日志系统。原来用 shared_ptr 到处传递，引用计数频繁增减，性能很差。改成 unique_ptr + 移动语义后，代码清晰了，性能也上来了。但我也犯过错——在无锁情况下让两个线程同时操作同一个 unique_ptr，结果调试了一整天。

我的建议：如果你在设计多线程接口，优先考虑「移动语义 + 互斥锁」的组合。这比用 shared_ptr 到处拷贝要高效得多，也比裸指针安全得多。

移动语义不是银弹，但它在线程间所有权传递这个场景下，确实是最优雅的工具。用好它，你的多线程代码会变得更简洁、更安全。

公众号:蓝海资料掘金营，微信deep3321

📚 课程目录

12、移动语义与多线程：移动语义在线程间传递所有权、std::async 与移动、移动与线程安全

12.1 线程间传递所有权：std::thread 与移动

12.2 std::async 与移动语义

12.3 移动与线程安全：一个容易被忽视的问题

12.4 安全实践：用移动语义配合锁

12.5 移动语义与线程安全的关系图

12.6 总结与个人经验