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 spawn<F>(&self, future: F) where 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
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
T: Send + 'static,
E: Send + 'static
Spawns a fiber and returns a future to monitor it's execution result.
fn run_fiber<T, E>(&mut self,
monitor: Monitor<T, E>)
-> Result<Result<T, MonitorError<E>>>
monitor: Monitor<T, E>)
-> Result<Result<T, MonitorError<E>>>
Runs until the monitored fiber exits.
fn run(self) -> Result<()>
Runs infinitely until an error happens.