Struct BackgroundWorker 

pub struct BackgroundWorker<C, R> { /* private fields */ }

A generic background worker that accepts commands of type C and returns results of type R via a command/response channel pair.

One or more worker threads share a single command channel via Arc<Mutex<Receiver<C>>> (competing-consumer pattern). An idle worker automatically picks up the next available command.

Type parameters

• C – command type sent from the UI thread to the worker(s)
• R – result type sent back from the worker(s) to the UI thread

Implementations

impl<C: Send + 'static, R: Send + 'static> BackgroundWorker<C, R>

pub fn new<F>(worker_count: usize, process: F) -> Self

where F: Fn(C) -> R + Send + Sync + 'static,

Spawns worker_count threads, each running process(cmd) -> result in a loop until the command channel disconnects.

pub fn new_with_init<T, F, G>(worker_count: usize, init: F, process: G) -> Self

where T: 'static, F: Fn() -> T + Send + Sync + 'static, G: Fn(&T, C) -> R + Send + Sync + 'static,

Like BackgroundWorker::new, but each worker thread first runs init() once and passes its value to every process(ctx, cmd) call.

Use this when workers need expensive per-thread state (e.g. an async runtime) that must not be rebuilt per command. The context never leaves the thread that created it, so T may be !Send.

pub fn send(&self, cmd: C)

Sends a command to the worker pool. The command is delivered to whichever worker thread acquires the lock first.

Logs an error when every worker has already exited: in that state the command cannot be delivered and is dropped, so callers should treat the request as lost.

pub fn try_receive(&self) -> Option<R>

Returns a completed result, or None if none is ready yet. This never blocks the calling thread.

Trait Implementations

impl<C, R> Debug for BackgroundWorker<C, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.