Rust Arc<；互斥锁<；T>&燃气轮机；内部闭包：应为实现`Fn`特性的闭包，但此闭包只实现`Fn`一次`

我正在尝试与闭包共享一个

Arc

。我得到一个错误，

closure是

FnOnce

，因为它将变量

shared\u wake\u deque\ucode>移出其环境：

use core::task::{Context, Poll, Waker};
use hyper::client::connect::{Connection, Connected};
use std::sync::{Arc, Mutex};
use std::collections::VecDeque;

pub type OnPollRead = Arc<dyn Fn(&mut Context<'_>, &mut tokio::io::ReadBuf<'_>) -> Poll<std::io::Result<()>> + Send + Sync>;
pub type OnPollWrite = Arc<dyn Fn(&mut Context<'_>, &[u8]) -> Poll<core::result::Result<usize, std::io::Error>> + Send + Sync>;

#[derive(Clone)]
pub struct CustomTransporter {
    on_poll_read: Option<OnPollRead>,
    on_poll_write: Option<OnPollWrite>,
}

pub struct OVPNClient {
}

impl OVPNClient {
    pub fn send(&self, buffer: &[u8]) {
        
    }
}

unsafe impl Send for OVPNClient {}


unsafe impl Send for CustomTransporter {}

impl CustomTransporter {
    pub fn new(on_poll_read: Option<OnPollRead>, on_poll_write: Option<OnPollWrite>) -> CustomTransporter {
        CustomTransporter{
            on_poll_read: on_poll_read,
            on_poll_write: on_poll_write
        }
    }
}

fn main () {
    let openvpn_client = Arc::new(Mutex::new(OVPNClient{}));

    let shared_wake_deque = Arc::new(Mutex::new(VecDeque::<Waker>::new()));
    
    let shared_wake_deque_ = shared_wake_deque.clone();
    let on_poll_read = Arc::new(|context: &mut Context, buffer: &mut tokio::io::ReadBuf| -> Poll<std::io::Result<()>> {
        let shared_wake_deque__ = shared_wake_deque_;
        Poll::Ready(Ok(()))
    });

    let on_poll_write = Arc::new(|context: &mut Context, buffer: &[u8]| -> Poll<core::result::Result<usize, std::io::Error>>{
        openvpn_client.lock().unwrap().send(buffer);
        Poll::Ready(Ok(0))
    });

    let connector = CustomTransporter::new(Some(on_poll_read), Some(on_poll_write));
}

use core:：task:：{Context，Poll，Waker}；
使用hyper:：client:：connect:：{Connection，Connected}；
使用std:：sync:：{Arc，Mutex}；
使用std:：collections:：VecDeque；
发布类型OnPollRead=Arc）->轮询+发送+同步>；
发布类型OnPollWrite=Arc，因为您有

let shared_wake_deque__ = shared_wake_deque_;

作为一项简单的作业，它与

let foo = vec![];
let foo2 = foo;

其中，运行代码将vec的所有权从
foo
转移到
foo2
。因为在lambda中有这个值，所以运行显式地将
shared\u wake\u deque\u
值的所有权转移到
shared\u wake\u deque\u
，这意味着
shared\u wake\u deque\u
不能再使用了。为了实现这一点，需要在轮询读取时
只能运行一次，否则多个对象将试图拥有同一个对象（因为它需要拥有它才能在将来的某个调用中使用，
上的
和之前任何调用中的
共享的\u wake\u deque\u
也必须拥有它）。因为这违反了Rust的安全保证，因为某些东西只能由一个东西拥有，所以您得到了这个错误

最有可能的是，你想要的是给我们一个参考，例如

let shared_wake_deque__ = &shared_wake_deque_;

通过引用
shared\u wake\u deque\u
，闭包可以运行多次并给出多个共享引用。但是，仅此一项，您就可以得到

error[E0597]: `shared_wake_deque_` does not live long enough

因为您试图引用在闭包外部声明的变量，而闭包可能会在删除
shared\u wake\u deque\u
后运行。要解决此问题，您需要闭包获得
shared\u wake\u deque\u
的所有权，这是通过使用
move
关键字来实现的，例如

let on_poll_read = Arc::new(move |context: &mut Context, buffer: &mut tokio::io::ReadBuf| -> Poll<std::io::Result<()>> {
    let shared_wake_deque__ = &shared_wake_deque_;

因为你有

let shared_wake_deque__ = shared_wake_deque_;

作为一项简单的作业，它与

let foo = vec![];
let foo2 = foo;

其中，运行代码将vec的所有权从
foo
转移到
foo2
。因为在lambda中有这一点，所以运行显式地将
shared_wake_deque_
值的所有权转移到
shared_wake_deque_
，这意味着
shared_wake_deque_
不能再使用了。为此，这是可能的e、 需要的是，
on\u poll\u read
只能运行一次，因为否则多个对象将试图拥有同一个对象（on\u poll\u read
，因为它需要拥有该对象才能在将来的某个调用中使用，并且来自任何以前调用的
共享唤醒\u deque\u
也必须拥有该对象）.因为这违反了Rust的安全保证，因为某些东西只能归一个东西所有，所以您会得到这个错误

最有可能的是，你想要的是给我们一个参考，例如

let shared_wake_deque__ = &shared_wake_deque_;

通过引用
shared\u wake\u deque\u
，闭包可以运行多次并给出多个共享引用。但是，仅此一项，您就可以得到

error[E0597]: `shared_wake_deque_` does not live long enough

因为您试图引用在闭包外部声明的变量，而闭包可能会在删除
shared\u wake\u deque\u
后运行。要解决此问题，您需要闭包获得
shared\u wake\u deque\u
的所有权，这是通过使用
move
关键字来实现的，例如

let on_poll_read = Arc::new(move |context: &mut Context, buffer: &mut tokio::io::ReadBuf| -> Poll<std::io::Result<()>> {
    let shared_wake_deque__ = &shared_wake_deque_;

（）