Rust遍历带节点锁的树/链表：寻求Idiomatic实现方案

你的问题核心在于：当前持有current的MutexGuard时，无法修改current变量——因为Rust借用检查器认为current被MutexGuard借用，禁止对其进行赋值操作。下面提供两种符合Rust习惯的解决方案，无需依赖rental crate。

方案一：安全惯用法（推荐） #

通过克隆Arc分离锁与原变量的生命周期，彻底避免借用冲突。原理是：锁绑定到克隆后的Arc实例，原current变量不再被借用，可自由更新。

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

fn main() {
    let mut current = get(0);
    
    loop {
        // 克隆当前节点的Arc，让锁与克隆体绑定，不影响原current变量
        let current_clone = current.clone();
        let current_lock = current_clone.lock().unwrap();
        
        // 获取下一个节点ID
        let next_node = match *current_lock {
            Content::Next(id) => get(id),
            Content::Terminal => return,
        };
        
        // 先锁定下一个节点（保证锁的持有顺序）
        let next_lock = next_node.lock().unwrap();
        
        // 释放当前节点的锁
        drop(current_lock);
        
        // 安全更新当前节点
        current = next_node;
        
        // 延续下一轮的锁，避免重复获取
        let mut current_lock = next_lock;
        loop {
            let next_node = match *current_lock {
                Content::Next(id) => get(id),
                Content::Terminal => return,
            };
            let next_lock = next_node.lock().unwrap();
            drop(current_lock);
            current = next_node;
            current_lock = next_lock;
        }
    }
}

fn get(id: u32) -> Arc<Mutex<Content>> {
    Arc::new(Mutex::new(if id == 4 {
        Content::Terminal
    } else {
        Content::Next(id + 1)
    }))
}

enum Content {
    Next(u32),
    Terminal,
}

为什么这能解决问题？ #

• current_clone是原Arc的副本，current_lock绑定到这个副本上，原current变量没有被借用。
• 完全遵循Rust的安全规则，无需任何unsafe代码，可读性和可维护性拉满。
• Arc克隆是原子操作，性能开销极低，几乎可以忽略。

方案二：简短unsafe代码（仅当极致性能需求时使用） #

如果想避免Arc克隆的微小开销，可以用unsafe代码解除MutexGuard与current变量的生命周期绑定。必须确保理解安全边界：

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

fn main() {
    let mut current: Arc<Mutex<Content>> = get(0);
    let mut current_lock = current.lock().unwrap();
    
    loop {
        let next_node = match *current_lock {
            Content::Next(id) => get(id),
            Content::Terminal => return,
        };
        
        // 先锁定下一个节点
        let next_lock = next_node.lock().unwrap();
        
        // 不安全转换生命周期：解除current_lock与current变量的绑定
        // 安全理由：drop current_lock前，current仍持有旧Arc的引用，旧Arc不会被销毁，锁的引用有效
        let static_guard: MutexGuard<'static, Content> = unsafe {
            std::mem::transmute(current_lock)
        };
        
        // 释放当前锁
        drop(static_guard);
        
        // 现在可以安全更新current
        current = next_node;
        
        // 更新锁为下一个节点的锁
        current_lock = next_lock;
    }
}

fn get(id: u32) -> Arc<Mutex<Content>> {
    Arc::new(Mutex::new(if id == 4 {
        Content::Terminal
    } else {
        Content::Next(id + 1)
    }))
}

enum Content {
    Next(u32),
    Terminal,
}

安全保证 #

• 在drop(static_guard)之前，current仍然持有旧Arc的引用，旧Arc的引用计数至少为1，不会被销毁，static_guard的引用始终有效。
• 转换后立即释放锁，不会出现悬垂引用或锁泄漏的问题。

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