move 关键字 ​

核心概念 ​

move 关键字用在闭包前面,强制闭包按值捕获所有引用到的外部变量,而不是借用。默认情况下编译器会选择最低权限的捕获方式(不可变借用或可变借用),但有些场景需要闭包拥有变量的所有权——最常见的是将闭包传递到另一个线程、或者让闭包的生命周期超过被捕获变量的作用域。move 不改变闭包体中对变量的操作方式,只改变捕获方式。

rust
fn main() {
    // 没有 move:编译器选择不可变借用
    let name = String::from("Rust");
    let greet = || println!("Hello, {}!", name);
    greet();
    println!("name 仍可用: {}", name);  // 只是借用,name 还在

    // 有 move:强制按值捕获,所有权转移到闭包
    let name2 = String::from("Rust");
    let greet2 = move || println!("Hello, {}!", name2);
    greet2();
    // println!("{}", name2);  // 编译错误:name2 已移入闭包
}

move 对不同类型的影响 ​

rust
fn main() {
    // === 非 Copy 类型:所有权转移 ===
    let data = vec![1, 2, 3];
    let show = move || println!("{:?}", data);
    show();
    // data 已被移入闭包,不能再用
    // println!("{:?}", data);  // 编译错误

    // === Copy 类型:复制一份,原变量不受影响 ===
    let x = 42;
    let y = 3.14;
    let flag = true;
    let show_copy = move || println!("x={}, y={}, flag={}", x, y, flag);
    show_copy();
    // Copy 类型不受影响,原变量仍可用
    println!("x={}, y={}, flag={}", x, y, flag);

    // === 混合类型 ===
    let num = 10;                        // Copy
    let text = String::from("hello");    // 非 Copy
    let mixed = move || {
        println!("num={}, text={}", num, text);
    };
    mixed();
    println!("num 仍可用: {}", num);    // Copy 的副本
    // println!("{}", text);             // 编译错误:已移入
}
类型无 move有 move
Copy 类型 (i32, f64, bool)不可变借用复制到闭包,原变量不受影响
非 Copy 类型 (String, Vec)借用(不可变或可变)所有权转移,原变量不可用
引用 (&T)借用引用复制引用到闭包

move 与线程 ​

move 最重要的应用场景是将闭包传给新线程。线程可能比当前函数活得更久,所以闭包必须拥有所有数据的所有权,不能借用可能已经被释放的变量。

rust
use std::thread;

fn main() {
    let message = String::from("来自主线程的消息");
    let count = 5;

    // move 闭包:将 message 和 count 移入线程
    let handle = thread::spawn(move || {
        for i in 1..=count {
            println!("[线程] 第{}次: {}", i, message);
        }
    });

    // message 已被移入线程,主线程不能再用
    // println!("{}", message);  // 编译错误

    // 等待线程完成
    handle.join().unwrap();

    // 没有 move 会编译错误,因为线程可能比 message 活得久
    // let handle2 = thread::spawn(|| {
    //     println!("{}", message);  // 编译错误:借用可能超过生命周期
    // });
}

move 但仍是 Fn ​

move 只改变捕获方式,不改变闭包实现的 trait。如果闭包体只读取数据,即使用了 move,闭包仍然实现 Fn(而不只是 FnOnce)。

rust
fn call_twice(f: impl Fn()) {
    f();
    f();
}

fn main() {
    let name = String::from("Rust");

    // move 把 name 移入闭包,但闭包体只读取 name
    // 所以闭包实现了 Fn,可以多次调用
    let greet = move || println!("Hello, {}!", name);

    call_twice(greet);  // 调用两次都没问题

    // 如果闭包体消耗了值,就只能调用一次
    let data = vec![1, 2, 3];
    let consume = move || {
        drop(data);  // 消耗 data
        println!("已消耗");
    };
    consume();
    // consume();  // 编译错误:FnOnce 只能调用一次
}

部分 move 与 clone 技巧 ​

当只想移动部分变量时,可以在 move 闭包外面先 clone 需要保留的变量。

rust
fn main() {
    let config = String::from("production");
    let data = vec![1, 2, 3, 4, 5];

    // 想在闭包中用 data(move),但还想在外面用 config
    let config_clone = config.clone();  // 克隆一份给闭包用

    let handle = std::thread::spawn(move || {
        // 闭包拥有 config_clone 和 data 的所有权
        println!("配置: {}", config_clone);
        println!("数据: {:?}", data);
    });

    // config 仍可用(闭包用的是 clone)
    println!("主线程配置: {}", config);
    // data 已移入闭包
    // println!("{:?}", data);  // 编译错误

    handle.join().unwrap();
}

基本示例 ​

用 move 闭包实现多线程并行处理:

rust
use std::thread;

fn main() {
    let items = vec![
        String::from("任务A"),
        String::from("任务B"),
        String::from("任务C"),
        String::from("任务D"),
    ];

    let mut handles = Vec::new();

    // 为每个任务创建一个线程
    for (index, item) in items.into_iter().enumerate() {
        // move 将 item 和 index 移入线程闭包
        let handle = thread::spawn(move || {
            // 模拟处理
            println!("[线程 {}] 开始处理: {}", index, item);
            thread::sleep(std::time::Duration::from_millis(100));
            let result = format!("{} - 完成", item);
            println!("[线程 {}] {}", index, result);
            result  // 线程返回值
        });
        handles.push(handle);
    }

    // 收集所有线程的结果
    let mut results = Vec::new();
    for handle in handles {
        let result = handle.join().unwrap();
        results.push(result);
    }

    println!("\n所有结果:");
    for result in &results {
        println!("  {}", result);
    }

    // move 闭包作为回调
    let prefix = String::from(">>>");
    let formatter = move |msg: &str| -> String {
        format!("{} {}", prefix, msg)
    };
    // prefix 已移入 formatter

    println!("{}", formatter("第一条消息"));
    println!("{}", formatter("第二条消息"));
}

常见问题 ​

问题一:什么时候必须用 move?

当闭包需要传给另一个线程(thread::spawn)、或者闭包的生命周期需要超过被捕获变量的作用域(如返回闭包、存储到结构体中)时,必须用 move。

问题二:move 闭包还能多次调用吗?

取决于闭包体。如果闭包体只读取数据(不消耗),move 闭包实现 Fn,可以多次调用。如果闭包体消耗了捕获的数据(如 drop),则只实现 FnOnce,只能调用一次。

问题三:move 之后还想用原变量怎么办?

在 move 之前 clone() 需要保留的变量。把 clone 传给闭包,原变量留在外面。

问题四:move 对引用类型有什么影响?

move 会把引用本身按值复制到闭包中。但引用的生命周期约束仍然存在,如果引用指向的数据可能被释放,编译器仍会报错。

适用场景 ​

  • 线程传参:thread::spawn(move || { ... })
  • 返回闭包:fn make() -> impl Fn() { move || ... }
  • 存储闭包:结构体字段中保存闭包
  • 异步任务:async block 中经常需要 move

注意事项 ​

  • move 强制所有被引用的变量按值捕获
  • Copy 类型 move 后原变量仍可用(复制了一份)
  • 非 Copy 类型 move 后原变量不可用(所有权转移)
  • move 不改变闭包体中对变量的操作方式
  • move 不决定闭包实现哪个 trait(Fn/FnMut/FnOnce)
  • 需要部分 move 时先 clone 需要保留的变量

总结 ​

move 关键字放在闭包前面,强制闭包按值捕获所有引用到的外部变量。对非 Copy 类型意味着所有权转移,对 Copy 类型是复制。最主要的应用场景是线程——thread::spawn 要求闭包拥有所有数据的所有权,因为线程可能比原作用域活得更久。move 只影响捕获方式,不改变闭包实现的 trait:如果闭包体只读取数据,move 闭包仍然实现 Fn。当需要 move 但还想在外部使用某些变量时,可以在 move 之前 clone。