1 files changed, 87 insertions, 0 deletions
diff --git a/third_party/rust/tokio-0.1.22/examples/blocking.rs b/third_party/rust/tokio-0.1.22/examples/blocking.rs
new file mode 100644
index 0000000000..e7d5da6c80
--- /dev/null
+++ b/third_party/rust/tokio-0.1.22/examples/blocking.rs
@@ -0,0 +1,87 @@
+//! An example of using blocking funcion annotation.
+//!
+//! This example will create 8 "heavy computation" blocking futures and 8
+//! non-blocking futures with 4 threads core threads in runtime.
+//! Each non-blocking future will print it's id and return immideatly.
+//! Each blocking future will print it's id on start, sleep for 1000 ms, print
+//! it's id and return.
+//!
+//! Note how non-blocking threads are executed before blocking threads finish
+//! their task.
+
+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;
+
+/// This future blocks it's poll method for 1000 ms.
+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);
+        // Try replacing this part with commnted code
+        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))
+        // println!("Blocking part annotated: {}!", self.value);
+        // thread::sleep(Duration::from_millis(1000));
+        // println!("Blocking done annotated: {}!", self.value);
+        // Ok(Async::Ready(()))
+    }
+}
+
+/// This future returns immideatly.
+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(()))
+    }
+}
+
+/// This future spawns child futures.
+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();
+}