Rust / 系统课时

综合重构所有权冲突模块

综合重构所有权冲突模块

当字符串处理、集合更新、返回引用和共享状态叠在同一个模块里,最容易出现“修好一个借用错误又冒出另一个”的连锁反应。本篇用一个可运行模块把借用范围、拥有型快照和共享可变状态重新分层,最终得到可验证的接口边界。

学习目标

  • 按借用持续时间定位 E0502、重复可变借用和共享状态冲突
  • 用短借用、拥有型快照与明确的变更方法重构接口
  • 验证 Rc<RefCell<T>> 外层共享与普通 &mut self 内层修改的边界

先识别冲突来自哪一层

这类模块通常同时存在四种压力:字符串清洗需要产生新值,集合更新需要 &mut self,查询方法可能返回绑定到 self 的引用,而多个调用者又想共享同一个状态。若把这些需求混成一个长借用,编译器就会阻止后续修改;若用 RefCell 绕过静态检查,重叠借用还可能在运行时 panic。

一个典型问题是先拿到指向状态内部的引用,再尝试修改同一状态。下面是片段示例,依赖后文的 Store 定义,不应单独运行:

rust
fn rename_and_print(store: &mut Store, id: u64) {
    let name = store.user_name(id).unwrap();

    // name 之后还要使用,因此这里不能再取得 store 的可变借用。
    store.rename_user(id, "Bob");

    println!("{name}");
}

这会触发类似 E0502 的错误:不可变借用仍然存活时,又尝试取得可变借用。正确方向不是复制整个 Store,而是缩短引用的使用范围,或在确实要跨越后续修改时取得拥有型快照。

把共享、借用和拥有值分成三层

下面的边界图把四个容易混淆的对象放到同一视图:Rc 负责共享所有权,RefCell 负责运行时借用检查,短期 Ref/RefMut 保护一次访问,而 UserView 用拥有数据脱离借用保护的生命周期。

共享状态与所有权边界

核心原则是:共享容器只存在于模块编排层,领域方法仍然接收普通的 &self 或 &mut self。这样大多数所有权错误仍由编译器静态发现,RefCell 的运行时风险被限制在很小的范围。

重构成短借用和拥有型快照

下面程序可直接用 rustc 或 Cargo 运行。user_name 在短读操作中返回 &str;user_view 则有意克隆必要字段,生成可以离开 RefCell 借用范围继续使用的快照。

rust
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;

#[derive(Debug)]
struct User {
    name: String,
    tags: Vec<String>,
}

#[derive(Debug)]
struct UserView {
    name: String,
    tags: Vec<String>,
}

#[derive(Default)]
struct Store {
    users: HashMap<u64, User>,
}

impl Store {
    fn rename_user(&mut self, id: u64, raw_name: &str) -> bool {
        let normalized = normalize(raw_name);
        let Some(user) = self.users.get_mut(&id) else {
            return false;
        };

        user.name = normalized;
        true
    }

    fn add_tag(&mut self, id: u64, raw_tag: &str) -> bool {
        let normalized = normalize(raw_tag);
        let Some(user) = self.users.get_mut(&id) else {
            return false;
        };

        // 去重逻辑与集合修改都封装在一次可变借用里。
        if !user.tags.contains(&normalized) {
            user.tags.push(normalized);
        }
        true
    }

    fn user_name(&self, id: u64) -> Option<&str> {
        self.users.get(&id).map(|user| user.name.as_str())
    }

    fn user_view(&self, id: u64) -> Option<UserView> {
        self.users.get(&id).map(|user| UserView {
            // 快照需要越过 RefCell 的借用保护,因此这里有目的地取得拥有值。
            name: user.name.clone(),
            tags: user.tags.clone(),
        })
    }
}

fn normalize(input: &str) -> String {
    input.trim().to_ascii_lowercase()
}

fn main() {
    let store = Rc::new(RefCell::new(Store::default()));

    {
        let mut state = store.borrow_mut();
        state.users.insert(
            1,
            User {
                name: "alice".to_owned(),
                tags: vec!["rust".to_owned()],
            },
        );
        state.rename_user(1, "  Alice Chen  ");
        state.add_tag(1, " Ownership ");
    } // RefMut 在这里结束,后续可以安全读取。

    {
        let state = store.borrow();
        println!("borrowed name={}", state.user_name(1).unwrap());
    }

    let view = {
        let state = store.borrow();
        state.user_view(1).unwrap()
    };
    println!("owned view={} {:?}", view.name, view.tags);

    // Rc 只解决多个所有者的问题;实际修改仍通过短期 borrow_mut 完成。
    let editor = Rc::clone(&store);
    editor.borrow_mut().add_tag(1, "API");

    let final_view = store.borrow().user_view(1).unwrap();
    println!("final tags={:?}", final_view.tags);
    println!("owners={}", Rc::strong_count(&store));
}

预期输出

text
borrowed name=alice chen
owned view=alice chen ["rust", "ownership"]
final tags=["rust", "ownership", "api"]
owners=2

这里的两次克隆只发生在 user_view:它的职责就是制造独立快照,因此复制是接口语义的一部分。相反,rename_user 和 add_tag 都只借用调用者传入的 &str,不会因为字符串清洗而要求调用者交出原字符串。

验证最终接口边界

重构后可以按调用方式逐项验收。短期读取时,在 Ref<Store> 存活期间使用 user_name 返回的 &str;需要跨越借用保护或后续还要修改状态时,先用 user_view 取得拥有型结果,再结束借用。所有写操作都集中在 &mut self 方法内,调用层只负责控制 borrow_mut 的范围。

Rc<RefCell<T>> 适合单线程共享可变状态;跨线程共享时应改用 Arc<Mutex<T>> 或 Arc<RwLock<T>>。无论外层容器是什么,稳定的设计原则不变:让引用尽快结束,让真正需要跨边界的数据拥有自身内容,让共享机制停留在最外层。

按自己的节奏,确认真正理解。

目录与阅读设置

记录一个想法

综合重构所有权冲突模块

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通