Struct holochain::prelude::dependencies::kitsune_p2p_types::dependencies::lair_keystore_api::dependencies::tokio::runtime::Handle
source · pub struct Handle { /* private fields */ }
Expand description
Handle to the runtime.
The handle is internally reference-counted and can be freely cloned. A handle can be
obtained using the Runtime::handle
method.
Implementations
sourceimpl Handle
impl Handle
sourcepub fn enter(&self) -> EnterGuard<'_>
pub fn enter(&self) -> EnterGuard<'_>
Enters the runtime context. This allows you to construct types that must
have an executor available on creation such as Sleep
or TcpStream
.
It will also allow you to call methods such as tokio::spawn
and Handle::current
without panicking.
sourcepub fn current() -> Handle
pub fn current() -> Handle
Returns a Handle
view over the currently running Runtime
.
Panics
This will panic if called outside the context of a Tokio runtime. That means that you must
call this on one of the threads being run by the runtime, or from a thread with an active
EnterGuard
. Calling this from within a thread created by std::thread::spawn
(for example)
will cause a panic unless that thread has an active EnterGuard
.
Examples
This can be used to obtain the handle of the surrounding runtime from an async block or function running on that runtime.
use tokio::runtime::Handle;
// Inside an async block or function.
let handle = Handle::current();
handle.spawn(async {
println!("now running in the existing Runtime");
});
thread::spawn(move || {
// Notice that the handle is created outside of this thread and then moved in
handle.spawn(async { /* ... */ });
// This next line would cause a panic because we haven't entered the runtime
// and created an EnterGuard
// let handle2 = Handle::current(); // panic
// So we create a guard here with Handle::enter();
let _guard = handle.enter();
// Now we can call Handle::current();
let handle2 = Handle::current();
});
sourcepub fn try_current() -> Result<Handle, TryCurrentError>
pub fn try_current() -> Result<Handle, TryCurrentError>
Returns a Handle view over the currently running Runtime
Returns an error if no Runtime has been started
Contrary to current
, this never panics
sourcepub fn spawn<F>(&self, future: F) -> JoinHandle<<F as Future>::Output> ⓘwhere
F: 'static + Future + Send,
<F as Future>::Output: 'static + Send,
pub fn spawn<F>(&self, future: F) -> JoinHandle<<F as Future>::Output> ⓘwhere
F: 'static + Future + Send,
<F as Future>::Output: 'static + Send,
Spawns a future onto the Tokio runtime.
This spawns the given future onto the runtime’s executor, usually a thread pool. The thread pool is then responsible for polling the future until it completes.
See module level documentation for more details.
Examples
use tokio::runtime::Runtime;
// Create the runtime
let rt = Runtime::new().unwrap();
// Get a handle from this runtime
let handle = rt.handle();
// Spawn a future onto the runtime using the handle
handle.spawn(async {
println!("now running on a worker thread");
});
sourcepub fn spawn_blocking<F, R>(&self, func: F) -> JoinHandle<R> ⓘwhere
F: 'static + FnOnce() -> R + Send,
R: 'static + Send,
pub fn spawn_blocking<F, R>(&self, func: F) -> JoinHandle<R> ⓘwhere
F: 'static + FnOnce() -> R + Send,
R: 'static + Send,
Runs the provided function on an executor dedicated to blocking. operations.
Examples
use tokio::runtime::Runtime;
// Create the runtime
let rt = Runtime::new().unwrap();
// Get a handle from this runtime
let handle = rt.handle();
// Spawn a blocking function onto the runtime using the handle
handle.spawn_blocking(|| {
println!("now running on a worker thread");
});
sourcepub fn block_on<F>(&self, future: F) -> <F as Future>::Outputwhere
F: Future,
pub fn block_on<F>(&self, future: F) -> <F as Future>::Outputwhere
F: Future,
Runs a future to completion on this Handle
’s associated Runtime
.
This runs the given future on the current thread, blocking until it is complete, and yielding its resolved result. Any tasks or timers which the future spawns internally will be executed on the runtime.
When this is used on a current_thread
runtime, only the
Runtime::block_on
method can drive the IO and timer drivers, but the
Handle::block_on
method cannot drive them. This means that, when using
this method on a current_thread runtime, anything that relies on IO or
timers will not work unless there is another thread currently calling
Runtime::block_on
on the same runtime.
If the runtime has been shut down
If the Handle
’s associated Runtime
has been shut down (through
Runtime::shutdown_background
, Runtime::shutdown_timeout
, or by
dropping it) and Handle::block_on
is used it might return an error or
panic. Specifically IO resources will return an error and timers will
panic. Runtime independent futures will run as normal.
Panics
This function panics if the provided future panics, if called within an asynchronous execution context, or if a timer future is executed on a runtime that has been shut down.
Examples
use tokio::runtime::Runtime;
// Create the runtime
let rt = Runtime::new().unwrap();
// Get a handle from this runtime
let handle = rt.handle();
// Execute the future, blocking the current thread until completion
handle.block_on(async {
println!("hello");
});
Or using Handle::current
:
use tokio::runtime::Handle;
#[tokio::main]
async fn main () {
let handle = Handle::current();
std::thread::spawn(move || {
// Using Handle::block_on to run async code in the new thread.
handle.block_on(async {
println!("hello");
});
});
}
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for Handle
impl Send for Handle
impl Sync for Handle
impl Unpin for Handle
impl !UnwindSafe for Handle
Blanket Implementations
impl<T> Any for Twhere
T: Any + ?Sized,
impl<T> Any for Twhere
T: Any + ?Sized,
fn type_id_compat(&self) -> TypeId
fn type_id_compat(&self) -> TypeId
impl<T> ArchivePointee for T
impl<T> ArchivePointee for T
type ArchivedMetadata = ()
type ArchivedMetadata = ()
fn pointer_metadata(
_: &<T as ArchivePointee>::ArchivedMetadata
) -> <T as Pointee>::Metadata
fn pointer_metadata(
_: &<T as ArchivePointee>::ArchivedMetadata
) -> <T as Pointee>::Metadata
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<F, W, T, D> Deserialize<With<T, W>, D> for Fwhere
W: DeserializeWith<F, T, D>,
D: Fallible + ?Sized,
F: ?Sized,
impl<F, W, T, D> Deserialize<With<T, W>, D> for Fwhere
W: DeserializeWith<F, T, D>,
D: Fallible + ?Sized,
F: ?Sized,
fn deserialize(
&self,
deserializer: &mut D
) -> Result<With<T, W>, <D as Fallible>::Error>
fn deserialize(
&self,
deserializer: &mut D
) -> Result<With<T, W>, <D as Fallible>::Error>
impl<T> FutureExt for T
impl<T> FutureExt for T
fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
fn with_current_context(self) -> WithContext<Self> ⓘ
fn with_current_context(self) -> WithContext<Self> ⓘ
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
sourcefn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
sourcefn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
impl<T> Pointable for T
impl<T> Pointable for T
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
fn to_subset(&self) -> Option<SS>
fn to_subset(&self) -> Option<SS>
self
from the equivalent element of its
superset. Read morefn is_in_subset(&self) -> bool
fn is_in_subset(&self) -> bool
self
is actually part of its subset T
(and can be converted to it).fn to_subset_unchecked(&self) -> SS
fn to_subset_unchecked(&self) -> SS
self.to_subset
but without any property checks. Always succeeds.fn from_subset(element: &SS) -> SP
fn from_subset(element: &SS) -> SP
self
to the equivalent element of its superset.