引言：并发编程的挑战（数据竞争、死锁）

在当今多核处理器普遍存在的计算环境中，并发编程已成为提升软件性能和响应能力的关键技术。通过同时执行多个任务，程序可以更有效地利用硬件资源，从而缩短响应时间并处理更大量的数据。然而，并发也带来了软件开发中最复杂、最难以捉摸的挑战。当多个执行线程试图同时访问和修改共享资源时，极易引发一系列难以预测的错误，其中最常见的便是数据竞争（Data Races）和死锁（Deadlocks）。

数据竞争发生在至少两个线程同时访问同一块内存，并且至少有一个访问是写入操作，而这些访问之间缺乏适当的同步机制。这种无序的访问会导致数据处于不一致状态，程序的行为变得不可预测，可能产生错误的结果，甚至导致程序崩溃。例如，想象一个简单的场景：两个线程同时尝试对一个共享的计数器变量进行递增操作。如果缺乏同步，线程 A 读取计数器为 5，线程 B 也读取计数器为 5。然后线程 A 将其递增到 6 并写入，线程 B 也将其递增到 6 并写入。最终结果是 6，而不是预期的 7，因为其中一个递增操作被覆盖了。这种错误往往难以复现，因为它们依赖于线程执行的时序，这使得调试工作异常艰难。

死锁则是一种更隐蔽的并发问题，它发生在两个或多个线程互相等待对方释放它们所需的资源，从而导致所有相关线程都无限期地停止执行。例如，线程 A 持有资源 X 并尝试获取资源 Y，而线程 B 持有资源 Y 并尝试获取资源 X。此时，两个线程都将永远无法继续，程序陷入停滞。死锁的发生通常涉及复杂的资源依赖关系，同样难以在开发阶段完全预测和避免。

这些并发问题不仅难以在开发阶段发现，更可能在生产环境中以间歇性、难以复现的方式出现，给调试和维护带来巨大困扰。许多编程语言依赖于运行时检查、锁机制或开发者的严格纪律来规避这些陷阱，但即便如此，并发错误依然是软件缺陷的常见来源，消耗了大量的开发和维护成本。

Rust 的并发哲学：编译时安全

Rust 的核心设计理念之一是实现**“无畏并发”（Fearless Concurrency）。这意味着 Rust 旨在通过其独特的所有权系统、借用检查器以及强大的类型系统，在编译时**而非运行时，捕获并消除绝大多数并发错误，尤其是数据竞争。这种前瞻性的方法极大地提升了并发程序的可靠性和安全性，让开发者能够自信地编写多线程代码，而无需担心常见的并发陷阱。

Rust 实现这一目标的基石在于其三大核心机制：

  1. 所有权系统： Rust 中的每个值都有一个明确的“所有者”，并且在任何给定时间，一个值只能有一个所有者。当所有者超出其作用域时，值会自动被清理，从而避免了内存泄漏和悬垂指针。这种单一所有权模型是 Rust 内存安全和并发安全的基础。
  2. 借用检查器： 借用检查器是 Rust 编译器的“守护者”，它强制执行严格的规则：在任何时候，你都可以拥有多个对数据的不可变引用（&T），但只能拥有一个可变引用（&mut T）。当存在可变引用时，不允许有其他任何引用（无论是可变还是不可变）。这从根本上杜绝了多个线程同时修改同一数据的可能性，从而消除了数据竞争。
  3. 生命周期： 生命周期注解确保了引用不会比它们所指向的数据活得更久。这解决了 C/C++ 中常见的“用后释放”（use-after-free）错误，并进一步增强了内存安全。在并发上下文中，生命周期确保了线程不会持有对已被其他线程释放或修改的数据的引用。

这些机制共同作用，为 Rust 的并发安全构建了坚不可摧的基础。它们在编译阶段就对代码进行严格审查，确保了在程序运行之前，所有潜在的数据竞争都已被识别并修复。这种编译时保证是 Rust 区别于其他语言的关键特性，它将并发错误的发现提前到开发阶段，显著降低了生产环境中的风险。

std::thread：创建新线程

Rust 标准库通过 std::thread 模块提供了创建和管理操作系统级线程的基本能力。你可以使用 thread::spawn 函数来启动一个新的线程，并在其中执行一个闭包。

  • thread::spawn 函数接受一个闭包作为参数，这个闭包包含了新线程需要执行的代码逻辑。
  • 这个闭包可以捕获其定义环境中的变量。然而，为了保证线程安全，这些被捕获的变量必须能够安全地在线程之间“移动”（即它们必须实现 Send Trait）。如果闭包需要拥有捕获变量的所有权，通常会使用 move 关键字，将变量的所有权转移到新线程的闭包中。
  • spawn 函数会返回一个 JoinHandle。这个句柄允许主线程等待新线程完成其执行，并通过 join() 方法获取新线程的返回值。这对于协调线程的生命周期和结果收集至关重要。

以下是一个简单的 std::thread 示例：

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..5 {
            println!("新线程打印: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..3 {
        println!("主线程打印: {}", i);
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().unwrap(); // 等待新线程完成
    println!("所有线程完成。");
}

在这个例子中，主线程和新线程并行执行，各自打印消息。handle.join() 确保主线程会等待新线程执行完毕才继续，避免了主线程提前退出导致新线程被终止。

消息传递并发：std::sync::mpsc（多生产者，单消费者）

Rust 强烈推荐并鼓励使用**消息传递（Message Passing）**作为一种安全且易于推理的并发范式。这种模型的核心思想是：线程之间不直接共享可变数据，而是通过发送消息来通信。这从根本上避免了直接共享内存所带来的复杂数据竞争问题，因为数据的所有权在线程之间明确转移。

  • std::sync::mpsc： 这个模块提供了“多生产者，单消费者”（Multiple Producer, Single Consumer）通道的实现。它允许一个或多个发送者（Sender）向一个单一的接收者（Receiver）发送数据。
  • 通道的组成： 一个通道由一对相互连接的端点组成：一个发送端（Sender<T>）和一个接收端（Receiver<T>）。T 代表了通过通道发送的数据类型。
  • 发送数据： 发送端通过其 send 方法将数据发送到通道。这个操作会将数据的所有权从发送线程转移到通道内部，再由通道转移给接收线程。
  • 接收数据： 接收端通过 recv 方法阻塞式地等待并接收数据，或者使用 try_recv 方法非阻塞式地尝试接收数据。当发送端关闭时，recv 会返回一个错误，表示通道已断开。
  • 所有权转移： 消息传递的关键在于所有权转移。当一个值通过通道发送时，其所有权会从发送线程转移到接收线程。这意味着发送线程在发送后不再拥有该数据，从而消除了多个线程同时拥有并修改同一数据的可能性，从根本上避免了数据竞争。
  • 线程安全： mpsc 通道本身是线程安全的。它内部处理了所有必要的同步机制，确保了数据在发送和接收过程中的完整性和一致性。

以下是一个使用 mpsc 通道进行消息传递的示例：

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel(); // 创建一个通道：发送端tx，接收端rx

    thread::spawn(move || { // 将tx的所有权移动到新线程
        let val = String::from("你好，世界！");
        println!("发送者发送: {}", val);
        tx.send(val).unwrap(); // 发送数据，val的所有权转移
        // 此时val已不再属于新线程，不能再使用
        thread::sleep(Duration::from_secs(1));
        tx.send(String::from("这是第二条消息")).unwrap();
    });

    let received = rx.recv().unwrap(); // 接收数据，阻塞直到有数据
    println!("接收者收到: {}", received);

    let received2 = rx.recv().unwrap();
    println!("接收者收到: {}", received2);
}

在这个例子中，发送者线程将 String 的所有权通过通道发送给接收者线程。一旦发送，发送者就不能再访问该 String，确保了数据安全。

共享状态并发：Mutex、Arc、RwLock

尽管消息传递是 Rust 推荐的并发模型，但在某些场景下，共享状态并发仍然是不可避免或更高效的选择。例如，当多个线程需要频繁地访问和修改同一个大型数据结构时，消息传递可能导致不必要的复制或复杂的协调。Rust 为此提供了强大的同步原语，以确保在多个线程之间安全地共享和修改数据。

  • Mutex：互斥锁

    • Mutex（Mutual Exclusion，互斥锁）是一种最基本的同步原语，它确保在任何给定时间，只有一个线程可以访问被其保护的数据。这通过“锁定”机制实现：线程必须首先获取锁，才能访问 Mutex 内部的数据。
    • 要访问 Mutex 内部的数据，线程必须首先获取锁。Rust 的 Mutex 通过 lock() 方法实现这一点，它会返回一个 MutexGuard。一旦成功获取锁，线程就获得了对数据的独占访问权，可以安全地读取或修改数据。
    • 访问完成后，线程必须释放锁，以便其他等待的线程有机会获取它。Rust 的 MutexGuard 利用 RAII（资源获取即初始化）机制，在超出作用域时自动释放锁。这意味着你无需手动调用 unlock()，锁会在 MutexGuard 被丢弃时自动释放，极大地简化了锁的管理，并防止了忘记释放锁的常见错误。
    • Rust 的 Mutex 具有“中毒”（Poisoning）特性：如果持有锁的线程在恐慌（panic）时没有释放锁，那么 Mutex 会被标记为“中毒”。后续尝试获取锁的线程会收到一个错误（PoisonError），而不是简单地死锁。这有助于防止因恐慌而导致的数据不一致，并允许程序优雅地处理这种异常情况。

  • Arc：原子引用计数（多线程共享所有权）

    • Arc（Atomic Reference Count）是 Rc（Reference Count）的线程安全版本。它允许在多个线程之间安全地共享数据的所有权。Rc 只能在单线程中使用，因为它内部的引用计数器不是原子操作，在多线程环境下会导致数据竞争。
    • Arc 内部使用原子操作来增加和减少引用计数。原子操作是不可中断的，即使在多线程环境下也能保证操作的完整性和正确性，从而确保引用计数的准确性。
    • 当所有 Arc 实例都超出作用域，即引用计数降为零时，被引用的数据才会被安全地清理。
    • Arc 通常与 Mutex 结合使用，以实现多线程对共享可变数据的安全访问。例如，Arc<Mutex<T>> 结构允许多个线程共享对一个 Mutex 的所有权，而 Mutex 则负责保护其内部数据 T 的可变访问。Arc 解决了所有权共享的问题，Mutex 解决了可变性共享的问题。

以下是一个结合 Arc 和 Mutex 的示例：

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

fn main() {
    let counter = Arc::new(Mutex::new(0)); // 创建一个共享的原子引用计数互斥锁
    let mut handles = vec![];

    for _ in 0..10 {
        let counter_clone = Arc::clone(&counter); // 克隆Arc，增加引用计数
        let handle = thread::spawn(move || {
            let mut num = counter_clone.lock().unwrap(); // 获取锁，阻塞直到可用
            *num += 1; // 修改共享数据
            // MutexGuard在num超出作用域时自动释放锁
        });
        handles.push(handle);
    }

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

    println!("最终计数: {}", *counter.lock().unwrap()); // 最终计数: 10
}

在这个例子中，Arc 使得 Mutex 可以在多个线程间共享，而 Mutex 则保证了对计数器变量的独占访问，避免了数据竞争。

  • RwLock：读写锁
    • RwLock（Read-Write Lock，读写锁）是一种比 Mutex 更灵活的锁机制，它在某些场景下能提供更好的并发性能。
    • RwLock 允许多个读取者（reader）同时访问被保护的数据，因为读取操作通常不会改变数据，所以并行读取是安全的。这通过 read() 方法实现，它返回一个 RwLockReadGuard。
    • 然而，当有写入者（writer）需要修改数据时，RwLock 会独占访问，阻止所有其他读取和写入操作，直到写入完成并释放锁。这通过 write() 方法实现，它返回一个 RwLockWriteGuard。
    • RwLock 适用于“读多写少”的场景。在这种情况下，它可以通过允许并行读取来显著提高并发性能，而 Mutex 则会强制所有访问（无论是读还是写）都串行化，可能成为性能瓶颈。
Send 和 Sync Trait：编译时线程安全保证

Send 和 Sync 是 Rust 中两个至关重要的标记 Trait（Marker Traits）。它们没有定义任何方法，其唯一目的是向 Rust 编译器表明某种类型具有特定的并发安全属性。编译器会根据这些 Trait 的实现情况，在编译时自动推导并强制执行线程安全规则，从而从根本上杜绝数据竞争。

  • Send：类型可以在线程间安全地移动

    • 如果一个类型实现了 Send Trait，这意味着它的所有权可以安全地从一个线程转移到另一个线程。当一个值从一个线程移动到另一个线程时，原线程将不再拥有该值，从而避免了两个线程同时访问同一数据的问题。
    • 几乎所有 Rust 的基本类型（如 i32、bool、String、Vec<T>）都自动实现了 Send。这些类型的数据在线程间移动时不会导致任何问题。
    • 示例： Box<T> 实现了 Send，前提是其内部的 T 也实现了 Send。这意味着你可以将一个 Box<i32> 从一个线程发送到另一个线程。
    • 非 Send 类型： Rc<T>（引用计数智能指针）没有实现 Send。这是因为 Rc 的引用计数器不是原子操作，如果 Rc 可以在线程间移动，那么多个线程可以同时修改其引用计数，导致数据竞争和不一致。因此，Rc 只能在单线程上下文中使用。
    • 编译器强制： 当你尝试将一个没有实现 Send Trait 的类型的所有权转移到另一个线程时（例如，通过 thread::spawn 闭包捕获一个 Rc<T>），Rust 编译器会立即报错，从而在程序运行之前就阻止了潜在的并发不安全行为。

    以下是一个 Send 违规的示例：

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

fn main() {
    let data = Rc::new(String::from("Hello"));
    // 尝试将Rc<String>移动到新线程，这将导致编译错误
    // error[E0277]: `Rc<String>` cannot be sent between threads safely
    // `Rc<String>` cannot be sent between threads safely
    // the trait `Send` is not implemented for `Rc<String>`
    // note: required for `std::sync::Arc<Rc<String>>` to be `Send`
    // note: required for the type `[closure@src/main.rs:7:24: 10:6]` to be `Send`
    let handle = thread::spawn(move || {
        println!("在新线程中: {}", data);
    });

    handle.join().unwrap();
}

编译器会明确指出 Rc<String> 没有实现 Send Trait，因此不能安全地在线程间移动。

Sync：类型可以在线程间安全地共享引用

  • 如果一个类型实现了 Sync Trait，这意味着它的不可变引用（&T）可以安全地在多个线程之间共享。换句话说，多个线程可以同时拥有对该类型数据的不可变引用，而不会导致数据竞争。
  • 一个重要的推论是：如果 T 是 Sync，那么 &T 也是 Send。这意味着一个不可变引用可以安全地发送到另一个线程，并在该线程中被解引用。
  • 示例： i32、String、&T (如果 T 是 Sync) 都实现了 Sync。Mutex<T> 实现了 Sync，前提是其内部的 T 也实现了 Send。这是因为 Mutex 本身提供了线程安全的访问机制，即使多个线程共享 Mutex 的引用，它们也必须通过 lock() 方法获取独占访问权才能修改内部数据。
  • 非 Sync 类型： Cell<T> 和 RefCell<T> 没有实现 Sync。这些类型提供了“内部可变性”（Interior Mutability），允许通过不可变引用修改其内部值。如果 &Cell<T> 可以在线程间共享，那么多个线程就可以同时通过不可变引用修改 Cell 内部的值，这将导致数据竞争。因此，Cell 和 RefCell 只能在单线程上下文中使用。
  • 编译器强制： 当你尝试在多个线程间共享一个没有实现 Sync Trait 的类型的引用时（例如，通过 Arc<RefCell<T>>），Rust 编译器会报错，从而防止了不安全的共享。

以下是一个 Sync 违规的示例：

use std::cell::RefCell;
use std::sync::Arc;
use std::thread;

fn main() {
    let data = Arc::new(RefCell::new(0));
    let mut handles = vec![];

    for _ in 0..3 {
        let data_clone = Arc::clone(&data);
        // 尝试在多个线程间共享RefCell的引用，这将导致编译错误
        // error[E0277]: `RefCell<i32>` cannot be shared between threads safely
        // `RefCell<i32>` cannot be shared between threads safely
        // the trait `Sync` is not implemented for `RefCell<i32>`
        // note: required for `std::sync::Arc<RefCell<i32>>` to be `Sync`
        // note: required for the type `[closure@src/main.rs:13:28: 16:10]` to be `Sync`
        let handle = thread::spawn(move || {
            let mut value = data_clone.borrow_mut();
            *value += 1;
            println!("线程修改后: {}", *value);
        });
        handles.push(handle);
    }

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

    println!("最终值: {}", *data.borrow());
}

编译器会明确指出 RefCell<i32> 没有实现 Sync Trait，因此不能安全地在线程间共享引用。

  • 编译器如何自动推导和强制执行：

    • Send 和 Sync 是自动实现的（auto-traits）。这意味着如果一个类型的所有组成部分（字段）都实现了 Send 或 Sync，那么该类型通常也会自动实现相应的 Trait。例如，如果一个结构体的所有字段都实现了 Send，那么该结构体也会自动实现 Send。这种自动推导机制大大简化了开发者的工作，无需手动为复合类型实现这些 Trait。
    • Rust 编译器在编译时会进行详尽的检查，分析所有跨线程边界的数据移动和共享操作。它会根据 Send 和 Sync Trait 的实现情况来判断这些操作是否符合线程安全规则。如果发现任何违反这些规则的行为，编译器会立即报错，从而在程序运行之前就消除了数据竞争的可能性。这种编译时保证是 Rust “无畏并发”哲学的核心体现，它将并发错误的发现提前到开发阶段，显著降低了生产环境中的风险。
结论：Rust 如何让并发编程变得更安全、更可预测

Rust 的并发模型是其最引人注目和最具创新性的特性之一。通过将所有权系统、借用检查器与 Send 和 Sync 这两个强大的标记 Trait 精妙地结合起来，Rust 在编译时提供了无与伦比的线程安全保证。

  • 彻底消除数据竞争： Rust 编译器在编译阶段就强制执行严格的规则，确保数据竞争在程序运行时根本不可能发生。这使得开发者能够专注于业务逻辑，而不是耗费大量精力去追踪和修复难以捉摸的并发 bug。
  • 显著提高可靠性： 开发者可以自信地编写复杂的并发代码，因为他们知道编译器已经验证了其线程安全性。这种信心极大地提升了软件的整体可靠性和稳定性。
  • 简化并发推理： 明确的所有权和借用规则，以及 Send/Sync 的语义，使得理解并发代码的行为变得更加直观和容易。开发者可以清晰地知道哪些数据可以安全地移动，哪些可以安全地共享，以及如何使用同步原语来保护共享状态。
  • 保持高性能： 所有的线程安全检查都在编译时完成，这意味着在程序运行时几乎没有额外的性能开销。Rust 的并发代码可以与 C++ 等低级语言一样高效，甚至在某些情况下更优，因为它避免了运行时锁的过度使用或不必要的同步。

无论是通过消息传递（如 mpsc）来避免共享可变状态，还是通过共享状态并发（如 Arc<Mutex<T>> 或 RwLock）来精细控制访问，Rust 都为开发者提供了构建高性能、高可靠并发应用程序所需的全部工具和坚实保证。这种“无畏并发”的哲学，使得 Rust 在处理复杂并发场景时，成为一个极具吸引力且功能强大的选择，真正实现了在安全性和性能之间取得完美平衡。

# rust # 开发语言 # 后端
Logo
AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

cover

我测试了一个0.9B模型，它竟然能自动区分多人讲话）

avatar AI Agent技术社区
cover

从一张商品图到正式上架：实测店匠 Shoplazza Athena，AI Agent 不只是聊天框

avatar AI Agent技术社区
cover

【AI Agent】《2026年9月 AI Agent全栈开发技术选型专项面试宝典》

avatar AI Agent技术社区