Struct Handle 

pub struct Handle { /* private fields */ }

A thread-safe handle used to schedule work on a runtime.

Implementations

impl Handle

pub fn current() -> Handle

Returns a handle to the runtime active on the current thread.

Panics

Panics if no runtime is active on the current thread.

pub fn notify(&self) -> Result<()>

Wakes the runtime’s driver.

Returns notification errors to the caller without retrying, unlike internal scheduler notifications.

pub fn busy_duration(&self) -> Option<Duration>

Returns the total time the runtime has been busy.

See Runtime::busy_duration. Always returns Some, the return type matches the other runtime backends.

pub fn current_turn(&self) -> Option<Duration>

Returns how long the current runtime turn has been running, None while the runtime is idle.

See Runtime::current_turn.

pub fn poll_count(&self) -> Option<u64>

Returns the number of runtime polls that ran scheduled tasks.

See Runtime::poll_count. Always returns Some.

pub fn poll_again_count(&self) -> Option<u64>

Returns the number of runtime polls that left scheduled tasks.

See Runtime::poll_again_count. Always returns Some.

pub fn self_wake_count(&self) -> Option<u64>

Returns the number of times a task woke itself while it was polled.

See Runtime::self_wake_count. Always returns Some.

pub fn current_task(&self) -> Option<&'static Location<'static>>

Returns the spawn location of the task the runtime is polling.

Returns None while the runtime is idle, handles driver events or between tasks. Can be read from other threads, for example to name the task that blocks a stalled runtime.

pub fn poll_histogram(&self) -> Option<Histogram>

Returns the histogram of runtime poll durations.

See Runtime::poll_histogram. Always returns Some.

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

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

Spawns a task on the handle’s runtime and returns a RemoteJoinHandle.

Spawning a task enables the task to execute concurrently to other tasks. There is no guarantee that a spawned task will execute to completion.

On the runtime thread the task is spawned directly. From other threads the future and output must be Send, the future is polled and dropped on the runtime thread and its output is returned through the handle. The handle is neither Send nor Sync, dropping it detaches the task.

let task = hnd.spawn(async { 42 });
assert_eq!(task.await.unwrap(), 42);

pub fn spawn_detached<F>(&self, future: F)

where F: Future + Send + 'static,

Spawns a new asynchronous task without a join handle.

The output is dropped on the runtime thread when the task completes, so it does not have to be Send.

Trait Implementations

impl Clone for Handle

fn clone(&self) -> Self

Shares the runtime’s queue without creating another runtime.

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

Performs copy-assignment from source.

impl Debug for Handle

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

Formats the value using the given formatter.