extern crate tokio;
extern crate tokio_threadpool;
use std::thread;
use std::time::Duration;
use tokio::prelude::*;
use tokio::runtime::Builder;
use tokio_threadpool::blocking;
struct BlockingFuture {
value: i32,
}
impl Future for BlockingFuture {
type Item = ();
type Error = ();
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
println!("Blocking begin: {}!", self.value);
blocking(|| {
println!("Blocking part annotated: {}!", self.value);
thread::sleep(Duration::from_millis(1000));
println!("Blocking done annotated: {}!", self.value);
})
.map_err(|err| panic!("Error in blocing block: {:?}", err))
}
}
struct NonBlockingFuture {
value: i32,
}
impl Future for NonBlockingFuture {
type Item = ();
type Error = ();
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
println!("Non-blocking done: {}!", self.value);
Ok(Async::Ready(()))
}
}
struct SpawningFuture;
impl Future for SpawningFuture {
type Item = ();
type Error = ();
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
for i in 0..8 {
let blocking_future = BlockingFuture { value: i };
tokio::spawn(blocking_future);
}
for i in 0..8 {
let non_blocking_future = NonBlockingFuture { value: i };
tokio::spawn(non_blocking_future);
}
Ok(Async::Ready(()))
}
}
fn main() {
let spawning_future = SpawningFuture;
let runtime = Builder::new().core_threads(4).build().unwrap();
runtime.block_on_all(spawning_future).unwrap();
}