Struct Runtime 

pub struct Runtime { /* private fields */ }

A runtime: worker shards and a blocking pool. Dropping it stops the workers, drops the tasks they still hold, and waits for the threads to exit; then, on the dropping thread, for what the handles those tasks held left behind (the bytes a socket’s write-behind holds, a file’s writes) to land, each for at most a minute, so nothing they accepted is lost.

Implementations

impl Runtime

pub fn enter(&self) -> EnterGuard<'_>

Sets this runtime on the calling thread until the guard drops, so the free functions use it outside block_on.

let runtime = nuclei::Runtime::builder().worker_threads(1).build().unwrap();
let _guard = runtime.enter();
let task = nuclei::spawn(async { 2 + 2 });
assert_eq!(runtime.block_on(task), 4);

pub fn id(&self) -> RuntimeId

The runtime’s id.

pub fn shutdown_background(self)

Stops the workers and returns at once: the worker threads drop their tasks and exit on their own, without being waited for, and what the handles of those tasks left behind is delivered on threads of its own.

impl Runtime

pub fn stats(&self) -> Stats

A snapshot of this runtime’s counters: Stats::shards lists its workers (stopped ones included) by place, and the blocking counts are its pool’s. The errors of threads that run no shard and the receive buffers missing are the process’s, as in stats(): they belong to no runtime. The shard of a thread inside this runtime’s block_on serves every runtime the thread enters, so only stats() lists it.

impl Runtime

pub fn builder() -> Builder

A builder with every setting at its default.

pub fn new() -> Result<Self>

Starts a runtime with every setting at its default.

Errors

As for Builder::build.

pub fn handle(&self) -> RuntimeHandle

A handle to spawn on this runtime from anywhere.

pub fn block_on<F: Future>(&self, future: F) -> F::Output

Runs future to its end on the calling thread; see block_on.

pub fn spawn<F>(&self, future: F) -> Task<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawns a task on one of the runtime’s shards; see spawn.

pub fn spawn_blocking<F, T>(&self, f: F) -> Task<T>

where F: FnOnce() -> T + Send + 'static, T: Send + 'static,

Runs f on the runtime’s blocking pool; see spawn_blocking.

pub fn shutdown_timeout(self, timeout: Duration)

Stops the workers and waits for them up to timeout; workers still running a task then are left to exit on their own. What the handles of the tasks dropped left behind gets the rest of timeout to land, on this thread; what has not by then is given up.

Trait Implementations

impl Debug for Runtime

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

Formats the value using the given formatter.

impl Drop for Runtime

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.