Struct tokio_threadpool::Sender
[−]
[src]
pub struct Sender { /* fields omitted */ }
Submit futures to the associated thread pool for execution.
A Sender
instance is a handle to a single thread pool, allowing the owner
of the handle to spawn futures onto the thread pool. New futures are spawned
using Sender::spawn
.
The Sender
handle is only used for spawning new futures. It does not
impact the lifecycle of the thread pool in any way.
Sender
instances are obtained by calling ThreadPool::sender
. The
Sender
struct implements the Executor
trait.
Methods
impl Sender
[src]
pub fn spawn<F>(&self, future: F) -> Result<(), SpawnError> where
F: Future<Item = (), Error = ()> + Send + 'static,
[src]
F: Future<Item = (), Error = ()> + Send + 'static,
Spawn a future onto the thread pool
This function takes ownership of the future and spawns it onto the thread pool, assigning it to a worker thread. The exact strategy used to assign a future to a worker depends on if the caller is already on a worker thread or external to the thread pool.
If the caller is currently on the thread pool, the spawned future will be assigned to the same worker that the caller is on. If the caller is external to the thread pool, the future will be assigned to a random worker.
If spawn
returns Ok
, this does not mean that the future will be
executed. The thread pool can be forcibly shutdown between the time
spawn
is called and the future has a chance to execute.
If spawn
returns Err
, then the future failed to be spawned. There
are two possible causes:
- The thread pool is at capacity and is unable to spawn a new future. This is a temporary failure. At some point in the future, the thread pool might be able to spawn new futures.
- The thread pool is shutdown. This is a permanent failure indicating that the handle will never be able to spawn new futures.
The status of the thread pool can be queried before calling spawn
using the status
function (part of the Executor
trait).
Examples
use futures::future::{Future, lazy}; // Create a thread pool with default configuration values let thread_pool = ThreadPool::new(); thread_pool.sender().spawn(lazy(|| { println!("called from a worker thread"); Ok(()) })).unwrap(); // Gracefully shutdown the threadpool thread_pool.shutdown().wait().unwrap();
Trait Implementations
impl Debug for Sender
[src]
fn fmt(&self, __arg_0: &mut Formatter) -> Result
[src]
Formats the value using the given formatter. Read more
impl Executor for Sender
[src]
fn status(&self) -> Result<(), SpawnError>
[src]
Provides a best effort hint to whether or not spawn
will succeed. Read more
fn spawn(
&mut self,
future: Box<Future<Item = (), Error = ()> + Send>
) -> Result<(), SpawnError>
[src]
&mut self,
future: Box<Future<Item = (), Error = ()> + Send>
) -> Result<(), SpawnError>
Spawns a future object to run on this executor. Read more
impl<'a> Executor for &'a Sender
[src]
fn status(&self) -> Result<(), SpawnError>
[src]
Provides a best effort hint to whether or not spawn
will succeed. Read more
fn spawn(
&mut self,
future: Box<Future<Item = (), Error = ()> + Send>
) -> Result<(), SpawnError>
[src]
&mut self,
future: Box<Future<Item = (), Error = ()> + Send>
) -> Result<(), SpawnError>
Spawns a future object to run on this executor. Read more
impl<T> Executor<T> for Sender where
T: Future<Item = (), Error = ()> + Send + 'static,
[src]
T: Future<Item = (), Error = ()> + Send + 'static,
fn execute(&self, future: T) -> Result<(), ExecuteError<T>>
[src]
Spawns a future to run on this Executor
, typically in the "background". Read more