Struct fibers::ThreadPoolExecutor
[−]
[src]
pub struct ThreadPoolExecutor { /* fields omitted */ }
An executor that executes spawned fibers on pooled threads.
Examples
An example to calculate fibonacci numbers:
use fibers::{Spawn, Executor, ThreadPoolExecutor}; use futures::{Async, Future, BoxFuture}; fn fib<H: Spawn + Clone>(n: usize, handle: H) -> BoxFuture<usize, ()> { if n < 2 { futures::finished(n).boxed() } else { let f0 = handle.spawn_monitor(fib(n - 1, handle.clone())); let f1 = handle.spawn_monitor(fib(n - 2, handle.clone())); f0.join(f1).map(|(a0, a1)| a0 + a1).map_err(|_| ()).boxed() } } let mut executor = ThreadPoolExecutor::new().unwrap(); let monitor = executor.spawn_monitor(fib(7, executor.handle())); let answer = executor.run_fiber(monitor).unwrap(); assert_eq!(answer, Ok(13));
Methods
impl ThreadPoolExecutor
[src]
fn new() -> Result<Self>
Creates a new instance of ThreadPoolExecutor
.
This is equivalent to ThreadPoolExecutor::with_thread_count(num_cpus::get() * 2)
.
fn with_thread_count(count: usize) -> Result<Self>
Creates a new instance of ThreadPoolExecutor
with the specified size of thread pool.
Implementation Details
Note that current implementation is very naive and should be improved in future releases.
Internally, count
threads are assigned to each of
the scheduler (i.e., fibers::fiber::Scheduler
) and
the I/O poller (i.e., fibers::io::poll::Poller
).
When spawn
function is called, the executor will assign a scheduler (thread)
for the fiber in simple round robin fashion.
If any of those threads are aborted, the executor will return an error as
a result of run_once
method call after that.
Trait Implementations
impl Debug for ThreadPoolExecutor
[src]
impl Executor for ThreadPoolExecutor
[src]
type Handle = ThreadPoolExecutorHandle
The handle type of the executor.
fn handle(&self) -> Self::Handle
Returns the handle of the executor.
fn run_once(&mut self) -> Result<()>
Runs one one unit of works.
fn run_fiber<T, E>(
&mut self,
monitor: Monitor<T, E>
) -> Result<Result<T, MonitorError<E>>>
&mut self,
monitor: Monitor<T, E>
) -> Result<Result<T, MonitorError<E>>>
Runs until the monitored fiber exits.
fn run_future<F: Future>(
&mut self,
future: F
) -> Result<Result<F::Item, F::Error>>
&mut self,
future: F
) -> Result<Result<F::Item, F::Error>>
Runs until the future is ready.
fn run(self) -> Result<()>
Runs infinitely until an error happens.
impl Spawn for ThreadPoolExecutor
[src]
fn spawn_boxed(&self, fiber: BoxFuture<(), ()>)
Spawns a fiber which will execute given boxed future.
fn spawn<F>(&self, fiber: F) where
F: Future<Item = (), Error = ()> + Send + 'static,
F: Future<Item = (), Error = ()> + Send + 'static,
Spawns a fiber which will execute given future.
fn spawn_fn<F, T>(&self, f: F) where
F: FnOnce() -> T + Send + 'static,
T: IntoFuture<Item = (), Error = ()> + Send + 'static,
T::Future: Send,
F: FnOnce() -> T + Send + 'static,
T: IntoFuture<Item = (), Error = ()> + Send + 'static,
T::Future: Send,
Equivalent to self.spawn(futures::lazy(|| f()))
.
fn spawn_monitor<F, T, E>(&self, f: F) -> Monitor<T, E> where
F: Future<Item = T, Error = E> + Send + 'static,
T: Send + 'static,
E: Send + 'static,
F: Future<Item = T, Error = E> + Send + 'static,
T: Send + 'static,
E: Send + 'static,
Spawns a fiber and returns a future to monitor it's execution result.
fn spawn_link<F, T, E>(&self, f: F) -> Link<(), (), T, E> where
F: Future<Item = T, Error = E> + Send + 'static,
T: Send + 'static,
E: Send + 'static,
F: Future<Item = T, Error = E> + Send + 'static,
T: Send + 'static,
E: Send + 'static,
Spawns a linked fiber. Read more
fn boxed(self) -> BoxSpawn where
Self: Sized + Send + 'static,
Self: Sized + Send + 'static,
Converts this instance into a boxed object.