pub fn spawn<F>(&self, future: F) -> Result<(), SpawnError>
    where
        F: Future<Item = (), Error = ()> + Send + 'static,
    {
        let mut s = self;
        tokio_executor::Executor::spawn(&mut s, Box::new(future))
    }
/// 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
///
/// ```rust
/// # extern crate tokio_threadpool;
/// # extern crate futures;
/// # use tokio_threadpool::ThreadPool;
/// use futures::future::{Future, lazy};
///
/// # pub fn main() {
/// // 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();
/// # }
/// ```
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.


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 .
pub fn spawn<F>(&self, future: F) -> Result<(), SpawnError>
    where
        F: Future<Item = (), Error = ()> + Send + 'static,
    {
        let mut s = self;
        tokio_executor::Executor::spawn(&mut s, Box::new(future))
    }
pub fn spawn < F > ( & self , future : F ) -> Result < ( ) , SpawnError > where F : Future < Item = ( ) , Error = ( ) > + Send + ' static , { let mut s = self ; tokio_executor :: Executor :: spawn ( & mut s , Box :: new ( future ) ) }
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.
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 .
&self
future
F
examples
None
extern crate tokio_threadpool;
None
extern crate futures;
None
use tokio_threadpool::threadpool;
use futures::future::{Future, lazy}.
use futures :: future :: { Future lazy } .
pub fn main() {
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().
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 () .
}
None