什么是数据竞争？为何必须避免？

数据竞争是指：多个线程同时访问同一块内存，且至少有一个访问是写入操作，且缺乏同步机制。这会导致不可预测的结果 —— 可能是计算错误（如计数器值异常）、程序崩溃，甚至出现 “时好时坏” 的诡异行为。

Rust 的核心设计目标之一，就是在编译期或运行期彻底杜绝数据竞争。它不依赖开发者的 “细心”，而是通过一套严格的规则和工具，从根源上避免这种风险。

---

1. 所有权与借用规则：从根本上约束访问权限

Rust 的所有权系统是避免数据竞争的基石，它通过编译期检查强制约束数据的访问方式：

• 所有权：每个值在任一时刻有且仅有一个 “所有者”。当所有者离开作用域（如函数执行结束），值会被自动释放（内存回收），避免 “无人管理” 的数据被随意访问。
• 借用规则：允许通过引用（&T 或 &mut T）临时访问数据，但有严格限制：
  • 同一时间，要么存在一个可变引用（&mut T），要么存在多个不可变引用（&T），绝对不能同时存在可变引用和不可变引用。
  • 引用的生命周期不能超过所有者的生命周期。

这些规则直接杜绝了 “多线程同时读写” 的可能 —— 编译器会在编译阶段拦截任何违反规则的代码。

fn main() {
    let mut data = 0;
    let ref1 = &mut data;  // 可变引用：独占修改权
    let ref2 = &data;     // ❌ 编译错误：不能同时存在可变引用和不可变引用
}

---

2. Send 与 Sync trait：标记线程安全的 “资格证”

Rust 通过两个标记 trait 明确类型的线程安全属性，限制跨线程数据传递：

• Send：表示类型的所有权可以安全转移到另一个线程（如 Arc<T>、String 实现了 Send）。
• Sync：表示类型可以安全地被多个线程共享（即 &T 是 Send 的，如 Mutex<T>、i32 实现了 Sync）。

编译器会自动为安全类型推导这两个 trait，而对不安全类型（如裸指针 *mut T、单线程引用计数 Rc<T>）则默认不实现。若强行跨线程传递不满足 Send/Sync 的类型，编译会直接失败。

示例：Rc<T> 因不实现 Send 无法跨线程

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

fn main() {
    let data = Rc::new(100);
    // ❌ 编译错误：Rc<i32> 不实现 Send，无法传递到新线程
    thread::spawn(move || println!("{}", data));
}

---

3. 内部可变性：安全的 “只读引用修改” 机制

内部可变性允许通过不可变引用修改数据，但 Rust 严格区分单线程与多线程场景：

单线程场景：Cell 与 RefCell

适用于单线程内需要灵活修改数据的场景，不保证线程安全（不实现 Sync）：

• Cell<T>：用于实现 Copy 的简单类型（如 i32），通过复制操作修改数据。
• RefCell<T>：用于复杂类型（如 Vec<T>），通过运行时检查确保借用规则（同一时间不允许同时存在可变与不可变引用）。

示例：RefCell 在单线程内安全修改

use std::cell::RefCell;

fn main() {
    let data = RefCell::new(vec![1, 2, 3]);
    // 通过不可变引用获取可变访问权
    let mut mut_data = data.borrow_mut();
    mut_data.push(4);  // 安全修改
}

多线程场景：Mutex 与 RwLock

适用于多线程共享且需要修改数据的场景，通过锁机制保证线程安全：

• Mutex<T>：互斥锁，同一时间仅允许一个线程访问数据（读 / 写均需获取锁）。
• RwLock<T>：读写锁，允许多个线程同时读取（共享锁），但写入时需独占（排他锁），适合 “读多写少” 场景。

通常与 Arc（多线程引用计数）配合使用：Arc 负责共享所有权，Mutex/RwLock 负责同步访问。

示例：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..5 {
        let c = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            let mut num = c.lock().unwrap();  // 获取锁（自动等待）
            *num += 1;  // 安全修改
        }));  // 离开作用域时自动释放锁
    }

    for h in handles { h.join().unwrap(); }
    println!("结果：{}", *counter.lock().unwrap());  // 输出 5
}

---

4. 消息传递：通过 “转移所有权” 避免共享

消息传递是另一种思路：不共享数据，而是通过 “通道” 传递数据所有权 —— 发送方发送数据后不再拥有它，接收方获得完整所有权，从根本上消除共享带来的竞争。

Rust 标准库 std::sync::mpsc 提供多生产者单消费者（MPSC）通道，支持线程间安全传递数据。

示例：线程通过通道传递消息

use std::sync::mpsc;
use std::thread;

fn main() {
    let (sender, receiver) = mpsc::channel();  // 创建通道

    // 生产者线程：发送数据（所有权转移）
    thread::spawn(move || {
        sender.send("消息1").unwrap();
        sender.send("消息2").unwrap();
    });

    // 接收者线程：获取数据（获得所有权）
    for msg in receiver {
        println!("收到：{}", msg);  // 依次输出 消息1、消息2
    }
}

---

5. 原子类型：无锁的轻量级同步

对于简单操作（如计数、标志位），原子类型（std::sync::atomic）提供硬件级的无锁同步，性能优于锁机制。

原子类型的操作是 “不可分割的”（不会被线程调度中断），支持 fetch_add（原子加）、load（原子读）等操作，常见类型有 AtomicI32、AtomicBool 等。

示例：原子类型实现无锁计数

use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread;

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

    for _ in 0..10 {
        let c = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            // 原子加1（Ordering::SeqCst 为安全内存顺序）
            c.fetch_add(1, Ordering::SeqCst);
        }));
    }

    for h in handles { h.join().unwrap(); }
    // 原子读取结果
    println!("结果：{}", counter.load(Ordering::SeqCst));  // 输出 10
}

---

6. 静态变量：全局数据的线程安全约束

静态变量（static）生命周期与程序一致，可全局访问，但需严格保证线程安全：

• 若仅读取：类型需实现 Sync（确保多线程读安全）。
• 若需修改：必须配合 Mutex 或原子类型（禁止使用 static mut，因其本质不安全）。

示例：线程安全的全局计数器

use std::sync::Mutex;

// 全局静态变量：用 Mutex 保证线程安全
static GLOBAL_COUNTER: Mutex<u32> = Mutex::new(0);

fn main() {
    // 多线程修改全局计数器
    let mut handles = vec![];
    for _ in 0..3 {
        handles.push(thread::spawn(|| {
            let mut num = GLOBAL_COUNTER.lock().unwrap();
            *num += 1;
        }));
    }

    for h in handles { h.join().unwrap(); }
    println!("全局计数：{}", GLOBAL_COUNTER.lock().unwrap());  // 输出 3
}

---

总结：Rust 防数据竞争的核心逻辑

Rust 通过多层次机制杜绝数据竞争，核心思路是 “规则约束 + 工具辅助”：

• 编译期拦截：所有权借用规则、Send/Sync trait 从源头阻止不安全访问。
• 运行时同步：Mutex/RwLock（锁机制）、原子类型（无锁同步）确保多线程操作有序。
• 设计规避：消息传递通过转移所有权消除共享，从根本上避免竞争。

根据场景选择合适的工具：共享且需修改用 Arc+Mutex/RwLock，传递数据用通道，简单计数用原子类型 —— 遵循这些规则，即可写出无数据竞争的 Rust 程序。