看起来这个问题是由传递一些变量给thread::spawn引起的，这要求接收到的变量具有'static生命周期（因为编译器无法证明线程不会永远存在，也无法证明传递的引用在线程生命周期内是否正常）。我知道3种方法来解决当我们在稳定的Rust中向thread::spawn传递具有非静态生命周期的变量时发生的问题

• 使用作用域线程（这不适合这种情况，因为我们不想在start中阻塞）

fn do_something(some_bool: &AtomicBool) {
    // This code causes error
    // borrowed data escapes outside of function [E0521] `some_bool` escapes the function body here
    // thread::spawn(move || {
    //     some_bool.store(true, Ordering::Relaxed);
    // });

    // This code blocks current thread until all spawned in `scope` threads finish execution
    thread::scope(|scope| {
        scope.spawn(move || {
            some_bool.store(true, Ordering::Relaxed);
        });
    });
    // Current thread will be blocked and code will reach this place only after all
    // spawned in `scope` threads finish execution
}

字符串

• 传递给thread::spawn的变量需要静态生存期（我们希望避免）

fn do_something_static_lifetime(some_bool: &'static AtomicBool) {
    thread::spawn(move || {
        some_bool.store(true, Ordering::Relaxed);
    });
}

型

• 使用unsafe和强制线程，我们希望生成的线程永远不会超过某些类型的生命周期，通过实现逻辑，这将强制线程在Drop中完成执行（这很可能是作者想要的）

struct MinimalEventLoopScheduler<'event_loop_scheduler> {
    action_queue: Mutex<VecDeque<Box<dyn FnOnce() + Send + 'event_loop_scheduler>>>,
    is_drop_finished: AtomicBool,
    is_drop_started: AtomicBool,
}

impl<'event_loop_scheduler> Drop for MinimalEventLoopScheduler<'event_loop_scheduler> {
    fn drop(&mut self) {
        // We need Release to prevent code from places before `drop()`
        // from being reordered after this line
        self.is_drop_started.store(true, Ordering::Release);

        // We need `Ordering::Acquire` to prevent compiler from reordering loop below fence to
        // places above before `self.is_drop_started.store(true, Ordering::Relaxed);`,
        // and also to prevent `self.is_drop_started.store(true, Ordering::Relaxed);`
        // from being reordered to places below(especially after loop)
        fence(Ordering::Acquire);

        loop {
            // Waiting until thread processes all tasks and finishes execution
            if self.is_drop_finished.load(Ordering::Relaxed) {
                break;
            }
        }

        // We need `AcqRel` to prevent loop from being reordered
        // to places after freeing memory and to prevent freeing
        // memory from being reordered to places before loop 
        fence(Ordering::AcqRel);

        // Memory will be freed here
    }
}

unsafe fn extend_action_queue_lifetime<'event_loop_scheduler>(
    t: &Mutex<VecDeque<Box<dyn FnOnce() + Send + 'event_loop_scheduler>>>,
) -> &'static Mutex<VecDeque<Box<dyn FnOnce() + Send + 'static>>> {
    transmute::<
        &Mutex<VecDeque<Box<dyn FnOnce() + Send + 'event_loop_scheduler>>>,
        &Mutex<VecDeque<Box<dyn FnOnce() + Send + 'static>>>,
    >(t)
}

unsafe fn extend_reference_lifetime<'t, T>(t: &T) -> &'static T {
    transmute::<&T, &T>(t)
}

impl<'event_loop_scheduler> MinimalEventLoopScheduler<'event_loop_scheduler> {
    pub fn new() -> Self {
        let event_loop_scheduler = Self {
            action_queue: Mutex::new(VecDeque::new()),
            is_drop_finished: AtomicBool::new(false),
            is_drop_started: AtomicBool::new(false),
        };

        event_loop_scheduler.start_event_loop();

        event_loop_scheduler
    }

    pub fn schedule(&self, action: impl FnOnce() + Send + 'event_loop_scheduler) {
        let action_box = Box::new(action);
        self.action_queue.lock().unwrap().push_back(action_box);
    }

    fn start_event_loop(&self) {
        // Without unsafe code there will be error
        // It is ok to use this unsafe logic, because we know for sure that thread won't outlive
        // `MinimalEventLoopScheduler`, because `Drop` implementation waits until thread is dropped,
        // so reference will outlive thread
        let action_queue = unsafe { extend_action_queue_lifetime(&self.action_queue) };
        let is_drop_finished = unsafe { extend_reference_lifetime(&self.is_drop_finished) };
        let is_drop_started = unsafe { extend_reference_lifetime(&self.is_drop_started) };

        thread::spawn(move || {
            let mut action_option;
            'event_loop: loop {
                {
                    // We do it in separate scope to decrease time under lock
                    action_option = action_queue.lock().unwrap().pop_front();
                }

                match action_option {
                    None => {
                        // It is ok to use `Relaxed` here, because it can't be reordered without
                        // breaking single-threaded logic, and we don't read/store non-atomic memory in `if` branch
                        if is_drop_started.load(Ordering::Relaxed) {
                            // We don't need to use `Release`, because we don't have memory
                            // changes which happen before `store` and which we want to make
                            // accessible to other threads(and which weren't made accessible by `lock`),
                            // and compiler can not reorder `action()` from previous iteration, because `action_queue.lock()`
                            // prevents reordering before and after itself, and compiler can reorder
                            // only next 2 lines(store and break) without breaking single-threaded logic,
                            // and reordering them is fine, since they don't have non-atomic memory
                            // which can be accessed from multiple threads
                            is_drop_finished.store(true, Ordering::Relaxed);
                            break 'event_loop;
                        }
                    }
                    Some(action) => {
                        action();
                    }
                }
            }
        });
    }
}

型