1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

//! Dynamic task executor.
//!
//! Inspired by golang runtime.
//!
//! It is okay to do blocking inside a task, the executor will
//! detect this, and scale the thread pool.
//!
//! But, please keep note that every time you do blocking, it will
//! create thread via [`thread::spawn`], and the number of thread you can create
//! is not unlimited, so the number of blocking task you can [`spawn`] is also not unlimited
//!
//! [`thread::spawn`]: https://doc.rust-lang.org/std/thread/fn.spawn.html
//! [`spawn`]: fn.spawn.html
//!
//! ## Example
//!
//! ```rust,ignore
//! use std::thread;
//! use std::time::Duration;
//!
//! use futures_timer::Delay;
//!
//! fn main() {
//!     lelet::spawn(async {
//!         for _ in 0..10 {
//!             Delay::new(Duration::from_secs(1)).await;
//!             println!("Non-blocking Hello World");
//!         }
//!     });
//!
//!     lelet::spawn(async {
//!         for _ in 0..10 {
//!             thread::sleep(Duration::from_secs(1));
//!             println!("Blocking Hello World");
//!         }
//!     });
//!
//!     thread::sleep(Duration::from_secs(11));
//! }
//! ```

#[macro_use]
mod utils;

mod executor;
mod thread_pool;

pub use executor::spawn;
pub use executor::JoinHandle;

#[doc(hidden)]
pub use utils::yield_now;