How to fix `self` escapes the method body here?

We want to pass to thread::spawn data, which it forces to have 'static lifetime, which causes error

borrowed data escapes outside of method [E0521]
`self` escapes the method body here

Note: requirement occurs because of the type `EventLoopGroupSchedulerWorkerThreadData<'_>`, which makes the generic argument `'_` invariant

Note: the struct `EventLoopGroupSchedulerWorkerThreadData<'event_loop_group_scheduler>` is invariant over the parameter `'event_loop_group_scheduler`

Help: see <https://doc.rust-lang.org/nomicon/subtyping.html>; for more information about variance

<hr>

We know for sure that data which we pass to thread::spawn will have same lifetime as 'event_loop_group_scheduler, because Drop implementation of EventLoopGroupScheduler continuously unparks potentially sleeping(while waiting for tasks to appear) event loop threads until all of them reach point in code in event loop which checks if we have no tasks and Drop was called, and break event loop and finish execution

Stable Rust doesn't let us pass data to thread::spawn without 'static requirement or scope(which blocks current thread until child thread finish execution, which we want to avoid), but we don't want to have such a strict requirement, especially since such strict requirement usually propagates

<hr>

Here is a reproducible example

struct EventLoopGroupScheduler<'event_loop_group_scheduler> {
    thread_count: usize,
    worker_thread_data_arc:
        Arc<EventLoopGroupSchedulerWorkerThreadData<'event_loop_group_scheduler>>,
    // We have `worker_thread_data_ptr` to optimize access to data in `worker_thread_data_arc`
    // in hot paths
    worker_thread_data_ptr:
        *const EventLoopGroupSchedulerWorkerThreadData<'event_loop_group_scheduler>,
}

struct EventLoopGroupSchedulerWorkerThreadData<'event_loop_group_scheduler> {
    // Some properties
    // ...
    action_queue_list: Vec<Mutex<VecDeque<Box<dyn FnOnce() + Send + 'event_loop_group_scheduler>>>>,
    // Some properties
    // ...
}

impl<'event_loop_group_scheduler> EventLoopGroupScheduler<'event_loop_group_scheduler> {
    pub fn new(
        max_possible_concurrent_thread_count: usize,
        thread_count: usize,
        os_timer_precision: Duration,
    ) -> Self {
        let worker_thread_data_arc = Arc::new(EventLoopGroupSchedulerWorkerThreadData {
            // Some properties
            // ...
            action_queue_list: (0..thread_count)
                .map(|_| Mutex::new(VecDeque::new()))
                .collect(),
            // Some properties
            // ...
        });
        let worker_thread_data_ptr = Arc::into_raw(worker_thread_data_arc.clone());
        let event_loop_group_scheduler = Self {
            thread_count,
            worker_thread_data_arc,
            worker_thread_data_ptr,
        };

        event_loop_group_scheduler.start_event_loop_group();

        event_loop_group_scheduler
    }

    fn start_event_loop_group(&self) {
        for thread_index in 0..self.thread_count {
            let worker_thread_data_arc_clone = self.worker_thread_data_arc.clone();

            let _join_handle = thread::spawn(move || {
                // This line causes error:
                //
                // borrowed data escapes outside of method [E0521]
                //
                // `self` escapes the method body here
                //
                // Note: requirement occurs because of the type `EventLoopGroupSchedulerWorkerThreadData<'_>`, which makes the generic argument `'_` invariant
                //
                // Note: the struct `EventLoopGroupSchedulerWorkerThreadData<'event_loop_group_scheduler>` is invariant over the parameter `'event_loop_group_scheduler`
                //
                // Help: see <https://doc.rust-lang.org/nomicon/subtyping.html>; for more information about variance
                let worker_thread_data = worker_thread_data_arc_clone.as_ref();
            });
        }
    }
}

You can never use thread::spawn with borrowed data, and your use of a lifetime for your dyn FnOnces means that they're allowed to contain borrowed data.

Your choices are:

• Don't allow borrowed data; remove the lifetime parameters and change the lifetime on the dyn FnOnce to 'static. This is probably what you will need to do.

• Use scoped threads. The scope function blocks on all threads terminating, so they can safely use borrowed data. However, this means you can't have a “start” operation that lets the threads run in the background.

I wanted to use 'static at first, as was suggested in https://stackoverflow.com/a/76568430/9566462, but then I thought that 'static is too strict requirement when we know that Drop implementation of EventLoopGroupScheduler will be unparking threads until all of them finish execution, so we know that moved to thread::spawn lifetime should be same as 'event_loop_group_scheduler

Stable Rust doesn't let us pass non-static lifetime to thread::spawn without waiting all threads, so we use this unsafe extend_lifetime hack(notice that it is a rare case when such solution is useful, and generally is not recommended, but maybe your case is similar, so read on if you didn't find other solutions acceptable)

struct EventLoopGroupScheduler<'event_loop_group_scheduler> {
    thread_count: usize,
    unsafe_worker_thread_data:
        UnsafeCell<EventLoopGroupSchedulerWorkerThreadData<'event_loop_group_scheduler>>,
}

struct EventLoopGroupSchedulerWorkerThreadData<'event_loop_group_scheduler> {
    // Some properties
    // ...
    action_queue_list: Vec<Mutex<VecDeque<Box<dyn FnOnce() + Send + 'event_loop_group_scheduler>>>>,
    // Some properties
    // ...
}

unsafe fn extend_lifetime<'event_loop_group_scheduler>(
    t: &EventLoopGroupSchedulerWorkerThreadData<'event_loop_group_scheduler>,
) -> &'static EventLoopGroupSchedulerWorkerThreadData<'static> {
    transmute::<
        &EventLoopGroupSchedulerWorkerThreadData<'event_loop_group_scheduler>,
        &EventLoopGroupSchedulerWorkerThreadData<'static>,
    >(t)
}

impl<'event_loop_group_scheduler> EventLoopGroupScheduler<'event_loop_group_scheduler> {
    pub fn new(
        max_possible_concurrent_thread_count: usize,
        thread_count: usize,
        os_timer_precision: Duration,
    ) -> Self {
        let unsafe_worker_thread_data = UnsafeCell::new(EventLoopGroupSchedulerWorkerThreadData {
            // Some properties
            // ...
            action_queue_list: (0..thread_count)
                .map(|_| Mutex::new(VecDeque::new()))
                .collect(),
            // Some properties
            // ...
        });
        let event_loop_group_scheduler = Self {
            thread_count,
            unsafe_worker_thread_data,
        };

        event_loop_group_scheduler.start_event_loop_group();

        event_loop_group_scheduler
    }

    fn start_event_loop_group(&self) {
        for thread_index in 0..self.thread_count {
            // We know for sure that Drop will be unparking threads until all
            // of them reach place in code where they will decide to finally break loop
            // and finish execution,
            // so we know that moved to `thread::spawn` lifetime should be same as 'event_loop_group_scheduler
            //
            // Stable Rust doesn't let us pass lifetime without waiting all threads,
            // so we use this lifetime hack
            let worker_thread_data =
                unsafe { extend_lifetime(&*self.unsafe_worker_thread_data.get()) };

            let _join_handle = thread::spawn(move || {
                // Usage of `worker_thread_data`
                let action_queue_mutex = unsafe {
                    worker_thread_data
                        .action_queue_list
                        .get_unchecked(thread_index)
                };

                // Some code
                // ...
            });

            // Some code
            // ...
        }
    }
}