Struct EncoderWorker 

pub struct EncoderWorker { /* private fields */ }

A persistent worker thread that executes submitted closures sequentially (in submission order). Designed for command-buffer encoding workloads where the cost of std::thread::spawn per task would dwarf the work.

The worker is single-threaded; submissions execute one-at-a-time. For parallelism with the main thread, the typical pattern is:

1. Spawn one EncoderWorker at process start.
2. Per token: submit half the encoding work to the worker, encode the other half on the main thread, wait for both to complete.

EncoderWorker is NOT a thread pool — for that, spawn multiple workers.

Implementations

impl EncoderWorker

pub fn spawn() -> Self

Spawn a new persistent worker thread. The thread runs until either Self::shutdown is called or the EncoderWorker is dropped.

The worker’s run-loop blocks on the channel; CPU usage is zero when idle.

pub fn submit<F>(&self, f: F) -> Result<(), &'static str>

where F: FnOnce() + Send + 'static,

Submit a closure for execution on the worker thread. Returns immediately; the closure runs asynchronously.

To wait for the closure to complete, the caller must arrange its own signaling (e.g., a (tx, rx) channel pair captured by the closure).

Errors

Returns Err if the worker thread has been shut down or has panicked.

pub fn shutdown(&mut self)

Cleanly shut down the worker. Drops the sender (closing the channel), then joins the worker thread. Returns once the worker has processed all in-flight tasks.

Trait Implementations

impl Drop for EncoderWorker

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.