Struct BackgroundTasks 

pub struct BackgroundTasks { /* private fields */ }

The worker pool itself. Insert as a resource once, at startup; every system that needs to offload work reaches for Res<BackgroundTasks> and calls spawn.

Cheap to clone (an internal channel sender) — clone it out of a Res borrow to move an owned handle into a detached future, e.g. from a system registered with AsyncExt::detach.

Implementations

impl BackgroundTasks

pub fn new(worker_count: usize) -> Self

Spawns worker_count OS threads, each pulling jobs off one shared, lock-free queue until the pool itself is dropped. A worker count around your CPU’s core count (minus one, to leave room for the main thread) is a reasonable default; tune based on actual measured load.

On wasm32 there are no OS threads to spawn, so worker_count is ignored and spawn_blocking queues jobs that never run — spawn_async is the one that’s web-compatible, since it drives the browser’s microtask queue via wasm_bindgen_futures::spawn_local instead of a worker thread.

pub fn spawn_blocking<T: Send + 'static>( &self, work: impl FnOnce() -> T + Send + 'static, ) -> TaskHandle<T>

Queue work to run on the pool. Returns a TaskHandle you can poll (non-blocking) from any system to check whether it’s done.

work runs on whichever worker thread picks it up next — don’t assume anything about timing or ordering relative to other spawned tasks unless you build that coordination yourself.

Native-only. There are no OS threads to block on in a browser tab, so on wasm32 this queues a job that never runs — use spawn_async instead, which works on both. The _blocking suffix names what makes this one platform-specific: it occupies its worker thread for as long as work runs, same as std::thread::spawn would.

pub fn spawn_async<T: Send + 'static>( &self, future: impl SpawnableFuture<T>, ) -> TaskHandle<T>

Queue an already-constructed future to run to completion, and return a TaskHandle you can poll for its result.

This is the primitive AsyncExt::detach uses under the hood; call it directly instead when you want the TaskHandle back to poll for a result, rather than firing the future off and forgetting it.

• Native: blocks whichever worker thread picks it up (via pollster::block_on) for as long as the future takes to resolve — there’s no cooperative multitasking between futures sharing a worker, so a slow future occupies that worker exclusively, same as a slow spawn_blocking closure would. The future must be Send to cross to that worker thread.
• Web: runs on the browser’s microtask queue via wasm_bindgen_futures::spawn_local, on the same (only) thread — so it does not need to be Send, which is what lets it capture !Send browser-bound types (JsValue, a web_sys handle, …).

Trait Implementations

impl Clone for BackgroundTasks

fn clone(&self) -> BackgroundTasks

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.