面试题：Rust借用规则与异步编程中的数据竞争防范

Rust借用规则在异步编程中防范数据竞争的原理

async/await语法与借用规则
- async函数返回一个实现了Future trait的类型。当await一个Future时，async函数的执行会暂停，直到被await的Future完成。在此过程中，Rust的借用规则确保变量的生命周期和借用关系符合安全原则。例如，在一个async函数中：

async fn async_func() {
    let mut data = String::from("hello");
    let ref_to_data = &mut data;
    // 这里如果在ref_to_data借用期间尝试再次借用data可变，会编译错误
}

这与同步代码中的借用规则一致，async函数并没有改变借用的基本规则，只是增加了异步执行的特性。

Future trait与借用规则
- 实现Future trait时，Rust的类型系统和借用规则同样适用。Future的poll方法签名为fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T>。其中，Pin<&mut Self>保证了Future在内存中的位置不会改变，防止悬空指针等问题。同时，借用规则确保在poll方法中对Self内部数据的访问是安全的。例如：

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

struct MyFuture {
    data: String,
}

impl Future for MyFuture {
    type Output = ();
    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<()> {
        let data_ref = &mut self.get_mut().data;
        // 对data进行操作，借用规则保证这里操作的安全性
        Poll::Ready(())
    }
}

tokio与借用规则
- tokio是Rust中常用的异步运行时。tokio的任务调度机制与Rust的借用规则协同工作。例如，tokio::spawn用于创建新的异步任务。当使用tokio::spawn时，传递给它的闭包捕获变量遵循借用规则。

use tokio;

async fn main() {
    let data = String::from("world");
    let handle = tokio::spawn(async move {
        // 使用move语义，data的所有权被转移到新任务中
        println!("{data}");
    });
    // 这里不能再访问data，因为所有权已被转移
    handle.await.unwrap();
}

可能出现的反模式及避免方法

反模式：异步任务间共享可变状态且未正确同步
- 示例：

use tokio;

async fn bad_example() {
    let mut shared_data = 0;
    let handle1 = tokio::spawn(async move {
        shared_data += 1;
    });
    let handle2 = tokio::spawn(async move {
        shared_data += 1;
    });
    handle1.await.unwrap();
    handle2.await.unwrap();
}

问题：这段代码会编译错误，因为shared_data在多个异步任务中尝试可变借用，违反了借用规则。即使不考虑编译错误，如果可以运行，也会出现数据竞争。
避免方法：使用Mutex或RwLock等同步原语。例如：

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

async fn good_example() {
    let shared_data = Arc::new(Mutex::new(0));
    let handle1 = tokio::spawn(async move {
        let mut data = shared_data.lock().unwrap();
        *data += 1;
    });
    let handle2 = tokio::spawn(async move {
        let mut data = shared_data.lock().unwrap();
        *data += 1;
    });
    handle1.await.unwrap();
    handle2.await.unwrap();
}

反模式：错误的闭包捕获
- 示例：

use tokio;

async fn bad_closure_capture() {
    let data = String::from("example");
    let handle = tokio::spawn(async {
        // 这里捕获data为不可变借用
        println!("{data}");
        // 下面这行会编译错误，因为在不可变借用期间尝试可变借用
        let mut new_data = data; 
    });
    handle.await.unwrap();
}

问题：闭包中先不可变借用data，之后又尝试将其变为可变，违反借用规则。
避免方法：根据需求使用move语义或正确处理借用关系。如果需要在任务中获取所有权，使用move闭包：

use tokio;

async fn good_closure_capture() {
    let data = String::from("example");
    let handle = tokio::spawn(async move {
        let mut new_data = data; 
        println!("{new_data}");
    });
    handle.await.unwrap();
}

星途面试题库

面试题：Rust借用规则与异步编程中的数据竞争防范

知识考点

面试题答案

Rust借用规则在异步编程中防范数据竞争的原理

可能出现的反模式及避免方法