面试题：Rust特征对跨线程内存安全的影响

Rust在多线程环境下保障内存安全的特征

所有权系统：
- Rust的所有权系统规定每个值都有一个唯一的所有者。在多线程环境中，当一个值被移动到另一个线程时，所有权随之转移，这样就避免了多个线程同时拥有对同一数据的写权限，从而防止数据竞争。例如：
```
let data = vec![1, 2, 3];
let handle = std::thread::spawn(move || {
    println!("Data in thread: {:?}", data);
});
handle.join().unwrap();
```
这里data被move到新线程中，主线程不再拥有data的所有权，也就不会出现主线程和新线程同时访问data导致的数据竞争。
借用规则：
- 借用规则确保在任何时刻，要么只能有一个可变引用（可写），要么可以有多个不可变引用（只读），但不能同时存在可变和不可变引用。在多线程中，这意味着如果一个线程持有可变引用，其他线程不能同时持有对同一数据的任何引用。例如：
```
let mut data = vec![1, 2, 3];
let ref1 = &data;
let ref2 = &data;
// 下面这行代码会报错，因为同时存在不可变引用时不能有可变引用
// let mut_ref = &mut data; 
```
Send和Sync特征：
- Send特征：标记类型可以安全地跨线程发送。如果一个类型实现了Send，意味着该类型的实例可以安全地从一个线程移动到另一个线程。大部分Rust内置类型都实现了Send。例如，i32实现了Send，可以在线程间传递：
```
let num = 10;
let handle = std::thread::spawn(move || {
    println!("Number in thread: {}", num);
});
handle.join().unwrap();
```
- Sync特征：标记类型可以安全地在多个线程间共享。如果一个类型实现了Sync，意味着可以在多个线程中同时持有对该类型实例的引用。同样，大部分Rust内置类型都实现了Sync。例如，&i32实现了Sync，可以在多个线程中同时使用：
```
let num = 10;
let shared_num = &num;
let handle1 = std::thread::spawn(move || {
    println!("Shared number in thread 1: {}", shared_num);
});
let handle2 = std::thread::spawn(move || {
    println!("Shared number in thread 2: {}", shared_num);
});
handle1.join().unwrap();
handle2.join().unwrap();
```

实现线程安全的共享数据结构

使用Mutex（互斥锁）：

Mutex（互斥锁）是一种同步原语，用于保护共享数据，确保同一时间只有一个线程可以访问数据。Mutex实现了Sync特征，所以可以在多线程间安全共享。
关键代码片段：

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

fn main() {
    let shared_data = Arc::new(Mutex::new(vec![1, 2, 3]));
    let mut handles = vec![];

    for _ in 0..10 {
        let data = Arc::clone(&shared_data);
        let handle = thread::spawn(move || {
            let mut data = data.lock().unwrap();
            data.push(4);
            println!("Data in thread: {:?}", data);
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }
    println!("Final data: {:?}", shared_data.lock().unwrap());
}

在这段代码中，Arc<Mutex<Vec<i32>>>用于在多个线程间共享一个Vec<i32>。Mutex确保同一时间只有一个线程可以获取锁并修改Vec，避免了数据竞争。Arc（原子引用计数）用于在多个线程间安全地共享Mutex。

使用RwLock（读写锁）：

RwLock允许在同一时间有多个线程进行读操作，或者只有一个线程进行写操作。这在多读少写的场景下能提高性能。RwLock也实现了Sync特征。
关键代码片段：

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

fn main() {
    let shared_data = Arc::new(RwLock::new(vec![1, 2, 3]));
    let mut handles = vec![];

    for _ in 0..5 {
        let data = Arc::clone(&shared_data);
        let handle = thread::spawn(move || {
            let data = data.read().unwrap();
            println!("Read data in thread: {:?}", data);
        });
        handles.push(handle);
    }

    for _ in 0..2 {
        let data = Arc::clone(&shared_data);
        let handle = thread::spawn(move || {
            let mut data = data.write().unwrap();
            data.push(4);
            println!("Write data in thread: {:?}", data);
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }
    println!("Final data: {:?}", shared_data.read().unwrap());
}

这里Arc<RwLock<Vec<i32>>>用于共享数据。读操作使用read方法获取读锁，允许多个线程同时读取；写操作使用write方法获取写锁，同一时间只允许一个线程写入，从而避免数据竞争。

星途面试题库

面试题：Rust特征对跨线程内存安全的影响

知识考点

面试题答案

Rust在多线程环境下保障内存安全的特征

实现线程安全的共享数据结构