Struct async_executors::exec::TokioTp [−][src]
pub struct TokioTp { /* fields omitted */ }
tokio_tp
only.Expand description
An executor that uses tokio::runtime::Runtime.
Example
The following example shows how to pass an executor to a library function.
use
{
futures :: { task::{ Spawn, SpawnExt } } ,
async_executors :: { TokioTpBuilder } ,
tokio::runtime :: { Builder } ,
std::convert :: { TryFrom } ,
futures::channel :: { oneshot, oneshot::Sender } ,
};
fn lib_function( exec: impl Spawn, tx: Sender<&'static str> )
{
exec.spawn( async
{
tx.send( "I can spawn from a library" ).expect( "send string" );
}).expect( "spawn task" );
}
fn main()
{
// You must use the builder. This guarantees that TokioTp is always backed up by a threadpool.
// You can set other configurations by calling `tokio_builder()` on TokioTpBuilder, so you get
// access to the `tokio::runtime::Builder`.
//
let exec = TokioTpBuilder::new().build().expect( "create tokio threadpool" );
let program = async
{
let (tx, rx) = oneshot::channel();
lib_function( &exec, tx );
assert_eq!( "I can spawn from a library", rx.await.expect( "receive on channel" ) );
};
exec.block_on( program );
}
Unwind Safety.
You must only spawn futures to this API that are unwind safe. Tokio will wrap it in std::panic::AssertUnwindSafe and wrap the poll invocation with std::panic::catch_unwind.
They reason that this is fine because they require Send + 'static
on the future. As far
as I can tell this is wrong. Unwind safety can be circumvented in several ways even with
Send + 'static
(eg. parking_lot::Mutex
is Send + 'static
but !UnwindSafe
).
You should make sure that if your future panics, no code that lives on after the spawned task has unwound, nor any destructors called during the unwind can observe data in an inconsistent state.
If a future is run with block_on
as opposed to spawn
, the panic will not be caught and the
thread calling block_on
will be unwound.
Note that unwind safety is related to logic errors, not related to the memory safety issues that cannot happen in safe rust (memory safety, undefined behavior, unsoundness, data races, …). See the relevant catch_unwind RFC and it’s discussion threads for more info as well as the documentation of std::panic::UnwindSafe.
Implementations
Forwards to Runtime::block_on.
See: tokio::runtime::Runtime::shutdown_timeout
This tries to unwrap the Arc
See: tokio::runtime::Runtime::shutdown_background
This tries to unwrap the Arc
Trait Implementations
fn spawn_blocking<F>(&self, f: F) -> BlockingHandle<R>ⓘNotable traits for BlockingHandle<T>impl<T: 'static> Future for BlockingHandle<T> type Output = T;
where
F: FnOnce() -> R + Send + 'static,
fn spawn_blocking<F>(&self, f: F) -> BlockingHandle<R>ⓘNotable traits for BlockingHandle<T>impl<T: 'static> Future for BlockingHandle<T> type Output = T;
where
F: FnOnce() -> R + Send + 'static,
impl<T: 'static> Future for BlockingHandle<T> type Output = T;
Runs the provided closure on a thread where blocking is acceptable.
fn spawn_blocking_dyn(
&self,
f: Box<dyn FnOnce() -> R + Send>
) -> BlockingHandle<R>ⓘNotable traits for BlockingHandle<T>impl<T: 'static> Future for BlockingHandle<T> type Output = T;
fn spawn_blocking_dyn(
&self,
f: Box<dyn FnOnce() -> R + Send>
) -> BlockingHandle<R>ⓘNotable traits for BlockingHandle<T>impl<T: 'static> Future for BlockingHandle<T> type Output = T;
impl<T: 'static> Future for BlockingHandle<T> type Output = T;
Runs the provided closure on a thread where blocking is acceptable. This part of the trait is object safe but your closure must be boxed and you cannot have a return value. Read more
fn spawn_handle_obj(
&self,
future: FutureObj<'static, Out>
) -> Result<JoinHandle<Out>, SpawnError>
fn spawn_handle_obj(
&self,
future: FutureObj<'static, Out>
) -> Result<JoinHandle<Out>, SpawnError>
Spawn a future and return a JoinHandle
that can be awaited for the output of the future.
fn yield_now(&self) -> YieldNowFutⓘNotable traits for YieldNowFutimpl Future for YieldNowFut type Output = ();
fn yield_now(&self) -> YieldNowFutⓘNotable traits for YieldNowFutimpl Future for YieldNowFut type Output = ();
impl Future for YieldNowFut type Output = ();
Await this future in order to yield to the executor.
Auto Trait Implementations
impl !RefUnwindSafe for TokioTp
impl !UnwindSafe for TokioTp
Blanket Implementations
Mutably borrows from an owned value. Read more
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
Spawns a task that polls the given future with output ()
to
completion. Read more
fn spawn_with_handle<Fut>(
&self,
future: Fut
) -> Result<RemoteHandle<<Fut as Future>::Output>, SpawnError> where
Fut: 'static + Future + Send,
<Fut as Future>::Output: Send,
fn spawn_with_handle<Fut>(
&self,
future: Fut
) -> Result<RemoteHandle<<Fut as Future>::Output>, SpawnError> where
Fut: 'static + Future + Send,
<Fut as Future>::Output: Send,
Spawns a task that polls the given future to completion and returns a future that resolves to the spawned future’s output. Read more
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more