Rust中解决多次借用问题：TcpStream与BytesMut借用冲突

问题场景1：结构体字段双重可变借用报错 #

你最初的代码因违反Rust借用规则无法编译：

#[tokio::test]
async fn test_refmut1() {
    struct Ctx {
        tcps: TcpStream,
        data: BytesMut,
    }
    async fn recv(ctx: Arc<Mutex<Ctx>>) {
        let mut ctx = ctx.lock().await;
        ctx.tcps.read_buf(&mut ctx.data).await.unwrap();
    }
}

核心原因是：调用read_buf时，需要同时可变借用Ctx的tcps和data字段，而Rust借用检查器不允许同一结构体的多个字段被同时可变借用。

问题场景2：RefCell使用方式错误 #

你尝试用RefCell实现内部可变性，但因类型不匹配仍编译失败：

#[tokio::test]
async fn test_refmut2() {
    struct Ctx {
        tcps: TcpStream,
        data: RefCell<BytesMut>,
    }
    
    async fn recv(ctx: Arc<Mutex<Ctx>>) {
        let mut ctx = ctx.lock().await;
        let tcps = &ctx.tcps;
        let mut data = ctx.data.borrow_mut();
        ctx.tcps.read_buf(&data).await.unwrap();
    }
}

这里read_buf需要&mut BytesMut类型参数，但你传递的是&RefMut<BytesMut>，类型不兼容。

解决方案1：正确利用RefCell的解引用特性 #

RefMut<T>实现了DerefMut<T>，可以通过解引用操作获取&mut T，直接修改参数即可解决类型问题：

use tokio::net::TcpStream;
use bytes::BytesMut;
use std::sync::{Arc, Mutex, RefCell};

#[tokio::test]
async fn test_refmut_fix() {
    struct Ctx {
        tcps: TcpStream,
        data: RefCell<BytesMut>,
    }
    
    async fn recv(ctx: Arc<Mutex<Ctx>>) {
        let mut ctx = ctx.lock().await;
        let mut data_ref = ctx.data.borrow_mut();
        // 通过&mut *data_ref将RefMut<BytesMut>转换为&mut BytesMut
        ctx.tcps.read_buf(&mut *data_ref).await.unwrap();
    }
}

RefCell的内部可变性机制会在运行时检查借用规则，避免了编译期的双重可变借用冲突。

解决方案2：拆分结构体为独立Mutex包裹字段 #

将tcps和data分别用Arc<Mutex>包裹，各自管理可变性，彻底避免结构体层面的借用冲突：

use tokio::net::TcpStream;
use bytes::BytesMut;
use std::sync::{Arc, Mutex};

#[tokio::test]
async fn test_refmut_split() {
    struct Ctx {
        tcps: Arc<Mutex<TcpStream>>,
        data: Arc<Mutex<BytesMut>>,
    }
    
    async fn recv(ctx: Arc<Ctx>) {
        let mut tcps = ctx.tcps.lock().await;
        let mut data = ctx.data.lock().await;
        tcps.read_buf(&mut data).await.unwrap();
    }
}

这种方式无需额外的内部可变性容器，适合字段独立性较强的场景。

解决方案3：使用UnsafeCell（不推荐） #

若你能手动保证线程安全和借用规则，可通过UnsafeCell绕过编译期检查，但这种方式存在安全风险，容易引发未定义行为：

use tokio::net::TcpStream;
use bytes::BytesMut;
use std::sync::{Arc, Mutex};
use std::cell::UnsafeCell;

#[tokio::test]
async fn test_refmut_unsafe() {
    struct Ctx {
        tcps: TcpStream,
        data: UnsafeCell<BytesMut>,
    }
    
    // 手动实现Send trait，确保类型可跨线程传递
    unsafe impl Send for Ctx {}
    
    async fn recv(ctx: Arc<Mutex<Ctx>>) {
        let mut ctx = ctx.lock().await;
        // 手动获取BytesMut的可变引用
        let data = unsafe { &mut *ctx.data.get() };
        ctx.tcps.read_buf(data).await.unwrap();
    }
}

内容的提问来源于stack exchange，提问作者progquester