24. 移动语义在多线程编程中有哪些应用场景？

多线程编程里，移动语义是个被低估的利器。很多人一提到多线程就只想到锁、条件变量、原子操作，却忽略了数据传递时的性能开销。我早年做高并发服务器时，就吃过这个亏——线程间传个大对象，拷贝开销直接把吞吐量打下来一半。

说白了，移动语义解决的是「线程间怎么高效地转移资源所有权」这个问题。你想想看，线程 A 生产数据，线程 B 消费数据，如果每次传递都来一次深拷贝，那多线程带来的并行优势就被拷贝开销抵消了。

场景一：用移动构造传递大数据对象

这是最直接的应用。线程间传递 std::vector、std::string、std::map 这类容器时，移动语义能避免拷贝底层内存。

#include <thread>
#include <vector>
#include <string>
#include <queue>
#include <mutex>
#include <condition_variable>

class DataProducer {
public:
    void produce(std::vector<std::string> data) {
        std::lock_guard<std::mutex> lock(mtx_);
        // 这里用 std::move 显式转移所有权
        queue_.push(std::move(data));
        cv_.notify_one();
    }

private:
    std::queue<std::vector<std::string>> queue_;
    std::mutex mtx_;
    std::condition_variable cv_;
};

class DataConsumer {
public:
    void consume(DataProducer& producer) {
        // 消费线程从队列中取出数据
        // 移动语义避免了 vector 内部数据的拷贝
    }
};

我在项目中遇到过类似场景：日志系统需要把格式化好的字符串从工作线程传给写盘线程。如果不做移动，每次日志写入都要拷贝几百 KB 的字符串，CPU 缓存都被污染了。用了移动语义后，性能提升很明显。

场景二：用 std::future 和 std::packaged_task 传递结果

std::future 本身支持移动语义，但很多人没意识到它内部存储的结果也可以移动。我记得有一次调试一个异步计算框架，发现返回大对象时性能不对劲，一查才发现是拷贝了 future 的结果。

#include <future>
#include <vector>
#include <iostream>

std::vector<int> compute_large_result() {
    std::vector<int> result(1000000, 42);
    // 做一些计算...
    return result;  // 这里触发移动构造或 RVO
}

int main() {
    // packaged_task 内部存储可移动的结果
    std::packaged_task<std::vector<int>()> task(compute_large_result);
    std::future<std::vector<int>> fut = task.get_future();

    std::thread t(std::move(task));  // task 本身也要移动
    t.detach();

    // 获取结果时也是移动操作
    std::vector<int> result = fut.get();  // 移动，不是拷贝
    std::cout << "Result size: " << result.size() << std::endl;
    return 0;
}

嗯，这里要注意：fut.get() 返回的是右值引用，所以赋值给 result 时触发移动构造。如果你写 auto result = fut.get();，也是移动语义。但如果你先声明变量再赋值，可能就变成拷贝了。

场景三：线程对象的移动与所有权转移

std::thread 本身是不可拷贝的，但可以移动。这意味着你可以把线程的所有权从一个作用域转移到另一个作用域。这在实现线程池或动态任务调度时特别有用。

#include <thread>
#include <vector>
#include <functional>

class ThreadPool {
public:
    void add_task(std::thread t) {
        // 移动线程对象到池中
        workers_.push_back(std::move(t));
    }

    void join_all() {
        for (auto& t : workers_) {
            if (t.joinable()) {
                t.join();
            }
        }
    }

private:
    std::vector<std::thread> workers_;
};

void worker_function(int id) {
    // 执行任务...
}

int main() {
    ThreadPool pool;
    std::thread t1(worker_function, 1);
    std::thread t2(worker_function, 2);

    // 转移线程所有权到池中
    pool.add_task(std::move(t1));
    pool.add_task(std::move(t2));

    // 此时 t1 和 t2 已经不再关联任何线程
    pool.join_all();
    return 0;
}

我曾经写过一个动态负载均衡系统，工作线程需要根据负载情况重新分配任务。利用 std::thread 的移动语义，我可以把线程对象在管理者和工作组之间来回传递，而不需要额外同步。

场景四：用移动语义实现无锁数据传递

在某些高性能场景下，我们可以结合移动语义和原子操作，实现线程间的无锁数据传递。比如用 std::atomic<std::unique_ptr<T>> 来传递独占所有权。

#include <atomic>
#include <memory>
#include <thread>

template<typename T>
class LockFreeChannel {
public:
    void send(std::unique_ptr<T> data) {
        // 原子地交换指针，无锁操作
        std::unique_ptr<T> old = std::atomic_exchange(&data_, std::move(data));
        // old 会被自动释放，或者你可以处理它
    }

    std::unique_ptr<T> receive() {
        // 取出当前数据，用空指针替换
        std::unique_ptr<T> result = std::atomic_exchange(&data_, nullptr);
        return result;  // 移动返回
    }

private:
    std::atomic<std::unique_ptr<T>> data_{nullptr};
};

// 使用示例
void producer(LockFreeChannel<std::vector<int>>& channel) {
    auto data = std::make_unique<std::vector<int>>(1000, 42);
    channel.send(std::move(data));
}

void consumer(LockFreeChannel<std::vector<int>>& channel) {
    auto data = channel.receive();
    if (data) {
        // 使用 data...
    }
}

这个模式我实际用在游戏引擎的渲染线程和逻辑线程之间。逻辑线程每帧生成渲染命令列表，通过这种无锁通道传递给渲染线程。移动语义保证了命令列表的底层内存不会被拷贝，原子操作保证了线程安全。

场景五：RAII 资源在线程间的安全转移

很多资源管理类（如文件句柄、网络连接、GPU 资源）都是不可拷贝的，但可以移动。多线程环境下，这些资源的所有权需要在不同线程间转移。

#include <thread>
#include <memory>
#include <fstream>

class FileHandle {
public:
    FileHandle(const std::string& path) 
        : file_(std::make_shared<std::ofstream>(path)) {}
    
    // 允许移动
    FileHandle(FileHandle&& other) noexcept 
        : file_(std::move(other.file_)) {}
    
    FileHandle& operator=(FileHandle&& other) noexcept {
        if (this != &other) {
            file_ = std::move(other.file_);
        }
        return *this;
    }
    
    // 禁止拷贝
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    
    void write(const std::string& data) {
        if (file_ && file_->is_open()) {
            *file_ << data;
        }
    }

private:
    std::shared_ptr<std::ofstream> file_;
};

// 在线程间传递文件句柄所有权
void thread_a() {
    FileHandle fh("log.txt");
    std::thread t([fh = std::move(fh)]() mutable {
        // 现在 fh 的所有权转移到了新线程
        fh.write("Hello from thread B\n");
    });
    t.detach();
    // 注意：此时 fh 已经无效，不能再使用
}

我记得在做一个分布式存储系统时，网络连接对象需要在 I/O 线程和业务处理线程之间传递。如果不用移动语义，就得用 shared_ptr 加引用计数，不仅开销大，还容易搞出循环引用。移动语义让所有权转移变得清晰且高效。

总结一下

移动语义在多线程编程中的价值，说白了就是两件事：减少拷贝开销和明确所有权转移。前者提升性能，后者降低心智负担。

我个人的经验是：只要线程间传递的对象内部有动态分配的内存（vector、string、unique_ptr 等），就应该优先考虑移动语义。别等到性能出问题了再回头优化，一开始就把移动语义用起来。