Trait tokio::executor::Executor
[−]
[src]
pub trait Executor { fn spawn(
&mut self,
future: Box<Future<Item = (), Error = ()> + 'static + Send>
) -> Result<(), SpawnError>; fn status(&self) -> Result<(), SpawnError> { ... } }
A value that executes futures.
The spawn
function is used to submit a future to an executor. Once
submitted, the executor takes ownership of the future and becomes
responsible for driving the future to completion.
The strategy employed by the executor to handle the future is less defined
and is left up to the Executor
implementation. The Executor
instance is
expected to call poll
on the future once it has been notified, however
the "when" and "how" can vary greatly.
For example, the executor might be a thread pool, in which case a set of threads have already been spawned up and the future is inserted into a queue. A thread will acquire the future and poll it.
The Executor
trait is only for futures that are Send
. These are most
common. There currently is no trait that describes executors that operate
entirely on the current thread (i.e., are able to spawn futures that are not
Send
). Note that single threaded executors can still implement Executor
,
but only futures that are Send
can be spawned via the trait.
Errors
The spawn
function returns Result
with an error type of SpawnError
.
This error type represents the reason that the executor was unable to spawn
the future. The two current represented scenarios are:
- An executor being at capacity or full. As such, the executor is not able to accept a new future. This error state is expected to be transient.
- An executor has been shutdown and can no longer accept new futures. This error state is expected to be permanent.
If a caller encounters an at capacity error, the caller should try to shed load. This can be as simple as dropping the future that was spawned.
If the caller encounters a shutdown error, the caller should attempt to gracefully shutdown.
Examples
use futures::future::lazy; my_executor.spawn(Box::new(lazy(|| { println!("running on the executor"); Ok(()) }))).unwrap();
Required Methods
fn spawn(
&mut self,
future: Box<Future<Item = (), Error = ()> + 'static + Send>
) -> Result<(), SpawnError>
&mut self,
future: Box<Future<Item = (), Error = ()> + 'static + Send>
) -> Result<(), SpawnError>
Spawns a future object to run on this executor.
future
is passed to the executor, which will begin running it. The
future may run on the current thread or another thread at the discretion
of the Executor
implementation.
Panics
Implementors are encouraged to avoid panics. However, a panic is permitted and the caller should check the implementation specific documentation for more details on possible panics.
Examples
use futures::future::lazy; my_executor.spawn(Box::new(lazy(|| { println!("running on the executor"); Ok(()) }))).unwrap();
Provided Methods
fn status(&self) -> Result<(), SpawnError>
Provides a best effort hint to whether or not spawn
will succeed.
This function may return both false positives and false negatives.
If status
returns Ok
, then a call to spawn
will probably
succeed, but may fail. If status
returns Err
, a call to spawn
will
probably fail, but may succeed.
This allows a caller to avoid creating the task if the call to spawn
has a high likelihood of failing.
Panics
This function must not panic. Implementors must ensure that panics do not happen.
Examples
use futures::future::lazy; if my_executor.status().is_ok() { my_executor.spawn(Box::new(lazy(|| { println!("running on the executor"); Ok(()) }))).unwrap(); } else { println!("the executor is not in a good state"); }
Implementations on Foreign Types
impl<E> Executor for Box<E> where
E: Executor + ?Sized,
[src]
E: Executor + ?Sized,
Implementors
impl Executor for DefaultExecutor
impl<'a> Executor for &'a Sender
impl Executor for Sender
impl Executor for CurrentThread
impl Executor for tokio::executor::current_thread::TaskExecutor
impl Executor for tokio::runtime::TaskExecutor