Rust I'；我很难理解如何使用crossbeam deque实现任务调度器

我遇到的问题是终身管理。我有一个注入器，在工作线程之间共享。我不得不使用

Arc

，因为

&

会引起终身抱怨。本地队列不是共享的，所以不用担心。然后我们来看看小偷

从文档中，可以跨线程共享窃取。因此，4个线程，每个线程有一个工作线程，最后每个线程有3个盗贼。然而，我再次遇到了生命周期问题，当线程生成时，这些问题似乎指向移动

self

。示例任务选取器表明，可以将偷取者表示为偷取者的一部分，我最后得到的是对偷取者的一部分引用

也许我误解了文档，我应该使用

Arc

风格的参考计数来管理注射器和窃贼的寿命。有人能帮我澄清一下吗

---

这里有一个简化（排序），有3个线程池。我已经删除了线程窃取器和注入器周围的生命周期管理，因为它们可以是

Arc

或

您是否可以包含指向所引用文档的链接？另外，如果可能的话，一些代码会有帮助（理想情况下是a）。我不确定它是否适用于您的情况，但当被迫使用
Arc
在线程之间共享内容时，我发现了一个好处-安全、可靠，并使线程之间的
Sync
值的“明显”共享正常工作。
// details on injector, worker and stealer can be found here:
// https://docs.rs/crossbeam/0.7.3/crossbeam/deque/index.html
struct ThreadData {
    injector: &deque::Injector::<Task>,     // common global queue
    task_q: deque::Worker::<Task>,          // local queue
    stealers: Vec<&deque::Stealer<Task>>    // stealers for other threads local queue
}
impl ThreadData {
    fn spawn(self) ->  Option<std::thread::JoinHandle<()>> {
        let thread = std::thread::spawn(move|| {
            find_task( &self.task_q, &self.injector, &self.stealers);
        });
        Some(thread)
    }
}
struct Worker {
    stealer: deque::Stealer<Task>,      // to be shared with other threads
    thread: Option<std::thread::JoinHandle<()>>
}

struct Factory {
    injector: deque::Injector::<Task> ,  // owner of the global queue
    workers: Vec<Worker>
}
impl Factory {
    fn new() -> Self {
        Self { injector: deque::Injector::<Task>::new(), workers: Vec::new() }
    }
    fn build_threadpool(mut self) {
        let mut t1 = ThreadData {
            injector: &self.injector,
            task_q: deque::Worker::<Task>::new_fifo(),
            stealers: Vec::new(),
        };
        let w1 = Worker {stealer: t1.task_q.stealer(), thread: None };

        let t2 = ThreadData {
            injector: &self.injector,
            task_q: deque::Worker::<Task>::new_fifo(),
            stealers: Vec::new(),
        };
        let w2 = Worker {stealer: t2.task_q.stealer(), thread: None};

        let t3 = ThreadData {
            injector: &self.injector,
            task_q: deque::Worker::<Task>::new_fifo(),
            stealers: Vec::new(),
        };
        let w3 = Worker {stealer: t3.task_q.stealer(), thread: None };

        t1.stealers.push(&w2.stealer);
        t1.stealers.push(&w3.stealer);

        t2.stealers.push(&w1.stealer);
        t2.stealers.push(&w3.stealer);

        t3.stealers.push(&w1.stealer);
        t3.stealers.push(&w2.stealer);

        // launch threads and save workers
        w1.thread = t1.spawn();
        w2.thread = t2.spawn();
        w3.thread = t3.spawn();

        self.workers.push(w1);
        self.workers.push(w2);
        self.workers.push(w3);
    }

}