Struct tokio::runtime::scheduler::multi_thread::handle::Handle

pub(crate) struct Handle {
    pub(super) shared: Shared,
    pub(crate) driver: Handle,
    pub(crate) blocking_spawner: Spawner,
    pub(crate) seed_generator: RngSeedGenerator,
}

Handle to the multi thread scheduler

Fields

shared: Shared

Task spawner

driver: Handle

Resource driver handles

blocking_spawner: Spawner

Blocking pool spawner

seed_generator: RngSeedGenerator

Current random number generator seed

Implementations

impl Handle

pub(crate) fn spawn<F>( me: &Arc<Self>, future: F, id: Id ) -> JoinHandle<F::Output> where F: Future + Send + 'static, F::Output: Send + 'static,

Spawns a future onto the thread pool

pub(crate) fn shutdown(&self)

pub(super) fn bind_new_task<T>( me: &Arc<Self>, future: T, id: Id ) -> JoinHandle<T::Output> where T: Future + Send + 'static, T::Output: Send + 'static,

impl Handle

pub(super) fn trace_core(&self, core: Box<Core>) -> Box<Core>

impl Handle

pub(super) fn schedule_task(&self, task: Notified<Arc<Handle>>, is_yield: bool)

pub(super) fn schedule_option_task_without_yield( &self, task: Option<Notified<Arc<Handle>>> )

fn schedule_local( &self, core: &mut Core, task: Notified<Arc<Handle>>, is_yield: bool )

fn next_remote_task(&self) -> Option<Notified<Arc<Handle>>>

fn push_remote_task(&self, task: Notified<Arc<Handle>>)

pub(super) fn close(&self)

fn notify_parked_local(&self)

fn notify_parked_remote(&self)

pub(super) fn notify_all(&self)

fn notify_if_work_pending(&self)

fn transition_worker_from_searching(&self)

fn shutdown_core(&self, core: Box<Core>)

Signals that a worker has observed the shutdown signal and has replaced its core back into its handle.

If all workers have reached this point, the final cleanup is performed.

fn ptr_eq(&self, other: &Handle) -> bool

Trait Implementations

impl Debug for Handle

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

Formats the value using the given formatter.

impl<'a> Lock<Synced> for &'a Handle

type Handle = InjectGuard<'a>

fn lock(self) -> Self::Handle

impl Overflow<Arc<Handle, Global>> for Handle

fn push(&self, task: Notified<Arc<Handle>>)

fn push_batch<I>(&self, iter: I)where I: Iterator<Item = Notified<Arc<Handle>>>,