无法使用 RwLock 和迭代器返回对临时值的引用

Question

我在其他问题中没有找到答案。

我已将我的问题减少到以下几点：

use std::sync::RwLock;

pub fn main() {
    iter_lock().for_each(|v| {
        println!("{}", v);
    });
}

fn get_lock<'a>() -> &'a RwLock<Vec<u32>> {
    static mut lock: RwLock<Vec<u32>> = RwLock::new(Vec::new());
    unsafe { &lock }
}

fn iter_lock<'a>() -> impl std::iter::Iterator<Item = &'a u32> {
    get_lock().read().unwrap().iter()
}

playground

上面的代码将无法编译并给出以下错误：

error[E0515]: cannot return reference to temporary value
  --> src/main.rs:15:5
   |
15 |     get_lock().read().unwrap().iter()
   |     --------------------------^^^^^^^
   |     |
   |     returns a reference to data owned by the current function
   |     temporary value created here
   |
   = help: use `.collect()` to allocate the iterator

• 请注意，上面的代码中不需要静态 mut，但我需要它，因为我需要在 impl 块内定义一个变量。
• 我需要返回一个迭代器，而不是 Vec，因为我试图避免任何分配，并且该函数将始终用于迭代。

我该如何解决这个问题？我不怕使用不安全的代码，所以也欢迎不安全的建议。

Answer 1

你可以尝试这样的事情：

use std::sync::{RwLock, RwLockReadGuard};

pub fn main() {
    let data = Data::new(&[1, 2, 3]);

    data.iter().for_each(|x| println!("{:?}", x));
}


struct Data {
    inner: RwLock<Vec<u32>>,
}

impl Data {
    fn new(vec: &[u32]) -> Self {
        Self {
            inner: RwLock::new(vec.to_vec()),
        }
    }

    fn iter(&self) -> Iter<'_> {
        let d = self.inner.read().unwrap();
        Iter::new(d)
    }
}

struct Iter<'a> {
    inner: RwLockReadGuard<'a, Vec<u32>>,
    current_index: usize,
}

impl<'a> Iter<'a> {
    pub fn new(inner: RwLockReadGuard<'a, Vec<u32>>) -> Iter<'a> {
        Self {
            inner,
            current_index: 0,
        }
    }
}

impl Iterator for Iter<'_> {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.current_index >= self.inner.len() {
            return None;
        }

        let item = &self.inner[self.current_index];
        self.current_index += 1;
        Some(*item)
    }
}