Rust / 技术文章

Rust Send 和 Sync 到底怎么用

Rust 多线程开发时,最常见的问题之一是“这个值为什么不能传给另一个线程”或“为什么加了引用后编译器又拒绝了”。这篇内容面向正在编写 Rust 并发程序的后端与系统开发者,重点解释 Send 与 Sync 分别约束什么、哪些标准类型满足这些约束,以及怎样根据编译器错误判断需要移动、共享还是加同步。读完后,你可以独立分析一个类型能否跨线程传递,并正确组织常见的 Arc、Mutex 与线程入口代码。

Send 解决什么问题

Send 表示一个类型的值可以安全地从一个线程转移到另一个线程。这里强调的是“转移所有权”,而不是多个线程同时访问同一个值。

线程 API 中常见的闭包边界就体现了这一点:

rust
use std::thread;

fn main() {
    let message = String::from("hello");

    let handle = thread::spawn(move || {
        println!("{message}");
    });

    handle.join().unwrap();
}

预期输出:

text
hello

String 实现了 Send,所以可以通过 move 将它的所有权交给新线程。原线程随后不再拥有这个 String。

因此可以把 Send 理解为:这个值适合把所有权交给另一个线程继续使用。

Sync 解决什么问题

Sync 关注的是共享引用。一个类型 T 实现 Sync,意味着 &T 可以安全地被多个线程同时持有。

Rust 中经常用一个等价关系理解它:

T: Sync 等价于 &T: Send。

也就是说,把一个共享引用送到另一个线程是否安全,是理解 Sync 的关键。

例如只读的 String 可以通过 Arc 在多个线程之间共享:

rust
use std::sync::Arc;
use std::thread;

fn main() {
    let message = Arc::new(String::from("hello"));
    let mut handles = Vec::new();

    for _ in 0..2 {
        let shared = Arc::clone(&message);
        handles.push(thread::spawn(move || {
            println!("{shared}");
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }
}

预期输出可能为:

text
hello
hello

这里不是 Arc 把所有类型都变成线程安全类型,而是它提供了原子引用计数;底层 String 本身满足共享访问所需的线程安全约束。

Send 和 Sync 不是一回事

判断并发类型时,最好先问两个不同的问题。

问题 关注的 trait 含义
能不能把值的所有权交给另一个线程 Send 跨线程移动值
能不能让多个线程共享 &T Sync 跨线程共享引用
多线程共享后还能不能修改 不只看 Sync 还要看内部可变性与同步机制

因此,“能跨线程移动”和“能被多个线程安全共享”不能混为一谈。

典型例子是 Arc<Mutex<T>>。Arc 解决的是多个线程共同持有所有权,Mutex 解决的是对共享可变状态进行互斥访问:

rust
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = Vec::new();

    for _ in 0..2 {
        let counter = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            let mut value = counter.lock().unwrap();
            *value += 1;
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("{}", *counter.lock().unwrap());
}

预期输出:

text
2

这里的职责可以拆开看:Arc 管共享所有权,Mutex 管并发修改,Send 与 Sync 则描述这些类型组合后是否满足线程边界要求。

哪些类型会触发典型错误

Rust 会拒绝把不具备线程安全保证的类型跨线程传递。最常见的例子是 Rc<T> 和 RefCell<T>。

Rc<T> 使用非原子的引用计数,因此不能安全地直接用于跨线程共享;多线程环境通常使用 Arc<T>。

可以从编译器错误中快速识别这类问题:

rust
use std::rc::Rc;
use std::thread;

fn main() {
    let value = Rc::new(String::from("hello"));

    thread::spawn(move || {
        println!("{value}");
    });
}

预期结果:编译失败,并指出 Rc<String> 不满足线程要求,错误信息通常会沿着 Rc 的类型关系指出缺失的 Send 约束。

这类错误不要只理解成“Rust 不让我开线程”。更准确的理解是:线程 API 要求闭包捕获的状态满足特定 trait,而当前类型没有提供对应的线程安全保证。

怎么根据使用场景选择类型

可以先按“所有权如何流动”来判断,而不是先背类型名称。

场景 常见选择 原因
一个值只交给新线程 T + move 转移所有权,关注 Send
多线程只读共享 Arc<T> 共享所有权,要求 T 满足相应线程安全约束
多线程共享并修改 Arc<Mutex<T>> 共享所有权 + 互斥修改
多线程共享并发读写,读多写少 Arc<RwLock<T>> 读写锁区分读与写
单线程内部可变 Rc<RefCell<T>> 适合单线程,不用于直接跨线程

例如下面这段代码中,Arc 是因为多个线程都需要持有同一份状态,而 Mutex 是因为状态会被修改:

rust
use std::sync::{Arc, Mutex};

struct State {
    count: usize,
}

fn main() {
    let state = Arc::new(Mutex::new(State { count: 0 }));
    println!("{}", state.lock().unwrap().count);
}

预期输出:

text
0

设计并发代码时,不要为了消除编译错误机械地加 Arc<Mutex<_>>。先确认数据是否真的需要跨线程共享,以及是否真的存在共享修改;很多场景只需要所有权移动,或者只读共享即可。

遇到 Send 和 Sync 报错怎么查

排查时可以按三个问题逐层缩小范围。

第一,看报错发生在“把值送进线程”还是“把引用送进线程”。前者通常与 Send 有关,后者通常与 Sync 有关。

第二,检查被捕获的数据中是否藏着不满足约束的成员。一个结构体是否实现 Send 或 Sync,往往取决于它内部字段的线程安全属性,因此问题可能不在你直接看到的外层类型。

第三,再决定是改变所有权模型,还是增加同步机制。例如:

rust
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let data = Arc::new(Mutex::new(vec![1, 2, 3]));
    let worker_data = Arc::clone(&data);

    let handle = thread::spawn(move || {
        worker_data.lock().unwrap().push(4);
    });

    handle.join().unwrap();
    println!("{:?}", data.lock().unwrap());
}

预期输出:

text
[1, 2, 3, 4]

真正重要的是识别线程边界上的数据关系:是“移动一次”,还是“多个线程共享”,还是“多个线程共享并修改”。一旦先把这个关系说清楚,Send、Sync、Arc 和 Mutex 的组合通常就会自然很多。

目录与阅读设置

记录一个想法

Rust Send 和 Sync 到底怎么用

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通