The thread operates on the bottom of its own queue. This requires zero locks. If a thread runs out of work, it becomes a "thief". It uses hardware-level Compare-And-Swap (CAS) atomic instructions to rip jobs from the top of a peer's queue. No system calls, no OS intervention—just pure silicon arbitration. 

 use crossbeam_deque::{Injector, Stealer, Worker, Steal}; use std::sync::{Arc, Mutex, Condvar}; use std::thread::JoinHandle; // The payload: a heap-allocated closure that owns its data and is thread-safe pub type Job = Box<dyn FnOnce() + Send + 'static>; // The Intercom: Used to wake up starving threads pub(crate) struct SleepSignal { keep_running: Mutex<bool>, cvar: Condvar, } // The Manager: Lives on the Main Thread pub struct JobStealer { global_queue: Arc<Injector<Job>>, sleep_signal: Arc<SleepSignal>, workers: Vec<JoinHandle<()>>, } // The Worker Brain: Moved permanently into the OS Thread struct WorkerContext { id: usize, local_deque: Worker<Job>, stealers: Vec<Stealer<Job>>, global_deque: Arc<Injector<Job>>, sleep_signal: Arc<SleepSignal>, } 

 impl WorkerContext { fn run(self) { loop { // Priority 1: Check the local, lock-free queue if let Some(job) = self.local_deque.pop() { job(); continue; } // Priority 2: Global Batch Steal // Take a chunk of jobs, put them in local, return one to run now if let Steal::Success(job) = self.global_deque.steal_batch_and_pop(&self.local_deque) { job(); continue; } // Priority 3: Peer Stealing (Hardware Atomics) let mut stole_job = false; for stealer in &self.stealers { if let Steal::Success(job) = stealer.steal_batch_and_pop(&self.local_deque) { stole_job = true; job(); break; } } if stole_job { continue; } // Priority 4: All queues are empty. Time to sleep. self.sleep(); } } } 

The Lost Wakeup: If the Main Thread signals new work a microsecond before the Worker goes to sleep, the Worker will miss the signal and sleep forever. We fix this by tying the Condvar to a Mutex. It makes the state-check and the sleep-command one unbreakable atomic transaction. The Spurious Wakeup: The Linux scheduler can randomly wake up parked threads even if no one pressed the alarm. We fix this by putting the sleep command inside a while loop. 

 impl WorkerContext { fn run(self) { loop { // Priority 1: Check the local, lock-free queue if let Some(job) = self.local_deque.pop() { job(); continue; } // Priority 2: Global Batch Steal // Take a chunk of jobs, put them in local, return one to run now if let Steal::Success(job) = self.global_deque.steal_batch_and_pop(&self.local_deque) { job(); continue; } // Priority 3: Peer Stealing (Hardware Atomics) let mut stole_job = false; for stealer in &self.stealers { if let Steal::Success(job) = stealer.steal_batch_and_pop(&self.local_deque) { stole_job = true; job(); break; } } if stole_job { continue; } // Priority 4: All queues are empty. Time to sleep. let mut keep_running_guard = self.sleep_signal.keep_running.lock().unwrap(); // The while loop protects against Spurious Wakeups while *keep_running_guard && self.global_deque.is_empty() { // wait() safely hands the Mutex key to the OS, goes to sleep,  // and catches the new key when it wakes up. keep_running_guard = self.sleep_signal.cvar.wait(keep_running_guard).unwrap(); } // If we woke up because the factory is closing, shatter the loop if !*keep_running_guard { std::process::exit(0); // In actual code, we break the outer loop } } } 

 impl Drop for JobStealer { fn drop(&mut self) { { let mut keep_running = self.sleep_signal.keep_running.lock().unwrap(); *keep_running = false; self.sleep_signal.cvar.notify_all(); // BLAST THE FIRE ALARM } // Mutex auto-unlocks here // Wait for threads to cleanly pack their desks let handles = std::mem::take(&mut self.workers); for worker in handles { worker.join().unwrap(); } } }