在Rust中实现资源消耗的安全包装器

问题背景 #

我正在使用资源消费者类型Consumer和资源类型Resource，相关API如下：

impl Consumer {
   pub fn consume(&self, r: Resource);
}

该API中无其他安全方式让Consumer消耗资源，且Resource不实现Copy trait。我希望创建WithConsumer<'a>类型，具备以下接口：

impl<'a> WithConsumer<'a> {
    pub fn new(r: Resource, c: &'a Consumer) -> Self;
    pub fn into_inner(self) -> Resource;
}

impl<'a> AsRef<'a, Resource> for WithConsumer<'a>;

impl<'a> AsMut<'a, Resource> for WithConsumer<'a>;

impl<'a> Drop for WithConsumer<'a>;

要求std::mem::drop(WithConsumer::new(resource, consumer))等价于consumer.consume(resource)，其他实现符合预期特性。由于无法用安全Rust实现，我给出了一个不安全实现（省略部分内容）：

use std::mem::ManuallyDrop;

pub struct WithConsumer<'a> {
   r: ManuallyDrop<Resource>,
   c: &'a Consumer,
}

impl WithConsumer<'a> {
    pub fn into_inner(mut self) -> Resource {
        unsafe {
            let answer = ManuallyDrop::take(&mut self.r);
            std::mem::forget(self);
            answer
        }
    }
}

impl<'a> Drop for WithConsumer<'a> {
    fn drop(&mut self) {
        unsafe {
            self.c.consume(ManuallyDrop::take(&mut self.r))
        }
    }
}

请问该抽象是否安全？标准库或crates.io上是否有现成的类似实现？

解答 #

1. 抽象安全性验证 #

你的WithConsumer实现是安全的，核心依据如下：

• ManuallyDrop阻断了Resource的自动drop逻辑，避免双重释放风险：资源只会在两个互斥路径中被处理——要么通过into_inner取出并跳过Drop，要么在Drop阶段被Consumer::consume消耗，不会出现重复操作。
• into_inner中调用std::mem::forget(self)确保当前实例的Drop逻辑不会触发，保证资源被取出后不会被二次处理。
• 只要Consumer::consume本身是安全的（即接收Resource后能正确处理，不引发未定义行为），整个抽象不会引入额外的不安全因素。

需要补充AsRef和AsMut的实现，这部分无需unsafe代码，直接引用ManuallyDrop内部的资源即可，确保引用生命周期与WithConsumer绑定：

impl<'a> AsRef<Resource> for WithConsumer<'a> {
    fn as_ref(&self) -> &Resource {
        &self.r
    }
}

impl<'a> AsMut<Resource> for WithConsumer<'a> {
    fn as_mut(&mut self) -> &mut Resource {
        &mut self.r
    }
}

2. 现有类似实现 #

• 标准库：没有完全匹配的实现，但std::sync::MutexGuard、std::io::BufReader等"资源持有器"类型的设计思路一致——通过Drop自动处理资源，同时提供into_inner方法取出内部资源。
• crates.io：
  • scopeguard：核心功能是创建作用域结束时自动执行指定操作的守卫，你的WithConsumer本质就是针对Consumer::consume的scopeguard，无需手写unsafe代码即可实现需求：

    use scopeguard::guard;
    
    let guard = guard(resource, |r| consumer.consume(r));
    // 通过as_ref/as_mut访问资源
    let resource = scopeguard::into_inner(guard); // 取出资源，不执行consume
    

  • owning_ref：专注于持有引用的同时拥有资源，功能更通用，你的场景是其典型应用之一。

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