9

我正在尝试创建一个struct需要 aPath并根据需要从指定的路径加载图像。这是我到目前为止所拥有的：

extern crate image;

use std::cell::{RefCell};
use std::path::{Path};
use image::{DynamicImage};

pub struct ImageCell<'a> {
    image: RefCell<Option<DynamicImage>>,
    image_path: &'a Path, 
}

impl<'a> ImageCell<'a> {
    pub fn new<P: AsRef<Path>>(image_path: &'a P) -> ImageCell<'a>{
        ImageCell { image: RefCell::new(None), image_path: image_path.as_ref() }
    }

    //copied from https://doc.rust-lang.org/nightly/std/cell/index.html#implementation-details-of-logically-immutable-methods
    pub fn get_image(&self) -> &DynamicImage {
        {
            let mut cache = self.image.borrow_mut();
            if cache.is_some() {
                return cache.as_ref().unwrap(); //Error here
            }

            let image = image::open(self.image_path).unwrap();
            *cache = Some(image);
        }

        self.get_image()
    } 
}

这无法编译：

src/image_generation.rs:34:24: 34:29 error: `cache` does not live long enough
src/image_generation.rs:34                 return cache.as_ref().unwrap();
                                                  ^~~~~
src/image_generation.rs:30:46: 42:6 note: reference must be valid for the anonymous lifetime #1 defined on the block at 30:45...
src/image_generation.rs:30     pub fn get_image(&self) -> &DynamicImage {
src/image_generation.rs:31         {
src/image_generation.rs:32             let mut cache = self.image.borrow_mut();
src/image_generation.rs:33             if cache.is_some() {
src/image_generation.rs:34                 return cache.as_ref().unwrap();
src/image_generation.rs:35             }
                           ...
src/image_generation.rs:32:53: 39:10 note: ...but borrowed value is only valid for the block suffix following statement 0 at 32:52
src/image_generation.rs:32             let mut cache = self.image.borrow_mut();
src/image_generation.rs:33             if cache.is_some() {
src/image_generation.rs:34                 return cache.as_ref().unwrap();
src/image_generation.rs:35             }
src/image_generation.rs:36 
src/image_generation.rs:37             let image = image::open(self.image_path).unwrap();
                           ...

我想我明白为什么，因为 的生命周期cache与borrow_mut().

反正有没有构造代码以便它工作？

4

1 回答 1

9

我并不完全相信您在这里需要内部可变性。但是，我确实认为您提出的解决方案通常很有用，因此我将详细说明实现它的一种方法。

您当前代码的问题在于它RefCell提供了动态借用语义。换句话说，借用 a 的内容RefCell对于 Rust 的借用检查器是不透明的。问题是，当您尝试归还一段&DynamicImage时间时，它仍然存在于. 中RefCell，无法RefCell跟踪其借用状态。如果 a允许这种情况发生，那么其他代码可能会RefCell覆盖. 哎呀！内存安全违规。RefCell&DynamicImage

出于这个原因，从 a 中借用一个值RefCell与您调用时返回的守卫的生命周期有关borrow_mut()。在这种情况下，守卫的生命周期是 的堆栈帧get_image，在函数返回后不再存在。因此，您不能借用RefCell您正在做的事情的内容。

另一种方法（同时保持内部可变性的要求）是将值移入和移出RefCell. 这使您能够保留缓存语义。

基本思想是返回一个包含动态图像的守卫以及指向它起源的单元格的指针。完成动态图像后，防护将被删除，我们可以将图像添加回单元格的缓存。

为了保持人体工程学，我们Deref在防护装置上实施，以便您可以假装它是一个DynamicImage. 这是带有一些注释和其他一些清理的代码：

use std::cell::RefCell;
use std::io;
use std::mem;
use std::ops::Deref;
use std::path::{Path, PathBuf};

struct ImageCell {
    image: RefCell<Option<DynamicImage>>,
    // Suffer the one time allocation into a `PathBuf` to avoid dealing
    // with the lifetime.
    image_path: PathBuf,
}

impl ImageCell {
    fn new<P: Into<PathBuf>>(image_path: P) -> ImageCell {
        ImageCell {
            image: RefCell::new(None),
            image_path: image_path.into(),
        }
    }

    fn get_image(&self) -> io::Result<DynamicImageGuard> {
        // `take` transfers ownership out from the `Option` inside the
        // `RefCell`. If there was no value there, then generate an image
        // and return it. Otherwise, move the value out of the `RefCell`
        // and return it.
        let image = match self.image.borrow_mut().take() {
            None => {
                println!("Opening new image: {:?}", self.image_path);
                try!(DynamicImage::open(&self.image_path))
            }
            Some(img) => {
                println!("Retrieving image from cache: {:?}", self.image_path);
                img
            }
        };
        // The guard provides the `DynamicImage` and a pointer back to
        // `ImageCell`. When it's dropped, the `DynamicImage` is added
        // back to the cache automatically.
        Ok(DynamicImageGuard { image_cell: self, image: image })
    }
}

struct DynamicImageGuard<'a> {
    image_cell: &'a ImageCell,
    image: DynamicImage,
}

impl<'a> Drop for DynamicImageGuard<'a> {
    fn drop(&mut self) {
        // When a `DynamicImageGuard` goes out of scope, this method is
        // called. We move the `DynamicImage` out of its current location
        // and put it back into the `RefCell` cache.
        println!("Adding image to cache: {:?}", self.image_cell.image_path);
        let image = mem::replace(&mut self.image, DynamicImage::empty());
        *self.image_cell.image.borrow_mut() = Some(image);
    }
}

impl<'a> Deref for DynamicImageGuard<'a> {
    type Target = DynamicImage;

    fn deref(&self) -> &DynamicImage {
        // This increases the ergnomics of a `DynamicImageGuard`. Because
        // of this impl, most uses of `DynamicImageGuard` can be as if
        // it were just a `&DynamicImage`.
        &self.image
    }
}

// A dummy image type.
struct DynamicImage {
    data: Vec<u8>,
}

// Dummy image methods.
impl DynamicImage {
    fn open<P: AsRef<Path>>(_p: P) -> io::Result<DynamicImage> {
        // Open image on file system here.
        Ok(DynamicImage { data: vec![] })
    }

    fn empty() -> DynamicImage {
        DynamicImage { data: vec![] }
    }
}

fn main() {
    let cell = ImageCell::new("foo");
    {
        let img = cell.get_image().unwrap(); // opens new image
        println!("image data: {:?}", img.data);
    } // adds image to cache (on drop of `img`)
    let img = cell.get_image().unwrap(); // retrieves image from cache
    println!("image data: {:?}", img.data);
} // adds image back to cache (on drop of `img`)

这里有一个非常重要的警告需要注意：这只有一个缓存位置，这意味着如果您get_image在第一个保护被删除之前第二次调用，那么将从头开始生成一个新图像，因为单元格将为空。这种语义很难更改（在安全代码中），因为您已经致力于使用内部可变性的解决方案。一般来说，内部可变性的全部意义在于在调用者无法观察到的情况下改变某些东西。事实上，这里应该就是这种情况，假设打开图像总是返回完全相同的数据。

这种方法可以概括为线程安全的（通过使用Mutex内部可变性而不是RefCell），并且可能通过根据您的用例选择不同的缓存策略来提高性能。例如，regex板条箱使用一个简单的内存池来缓存已编译的正则表达式状态。由于此缓存对调用者应该是不透明的，因此它使用与此处概述的完全相同的机制以内部可变性来实现。

于 2015-08-18T02:54:24.483 回答