mirror of
https://github.com/tokio-rs/tokio.git
synced 2026-08-24 00:00:11 +02:00
Carl Lerche
db620b42ec
Currently, the timer uses a `Now` trait to abstract the source of time. This allows time to be mocked out. However, the current implementation has a number of limitations as represented by #288 and #296. The main issues are that `Now` requires `&mut self` which prevents a value from being easily used in a concurrent environment. Also, when wanting to write code that is abstract over the source of time, generics get out of hand. This patch provides an alternate solution. A new type, `Clock` is provided which defaults to `Instant::now` as the source of time, but allows configuring the actual source using a new iteration of the `Now` trait. This time, `Now` is `Send + Sync + 'static`. Internally, `Clock` stores the now value in an `Arc<Now>` value, which introduces dynamism and allows `Clock` values to be cloned and be `Sync`. Also, the current clock can be set for the current execution context using the `with_default` pattern. Because using the `Instant::now` will be the most common case by far, it is special cased in order to avoid the need to allocate an `Arc` and use dynamic dispatch.
71 lines
2.0 KiB
Rust
71 lines
2.0 KiB
Rust
//! A runtime implementation that runs everything on the current thread.
|
|
//!
|
|
//! [`current_thread::Runtime`][rt] is similar to the primary
|
|
//! [`Runtime`][concurrent-rt] except that it runs all components on the current
|
|
//! thread instead of using a thread pool. This means that it is able to spawn
|
|
//! futures that do not implement `Send`.
|
|
//!
|
|
//! Same as the default [`Runtime`][concurrent-rt], the
|
|
//! [`current_thread::Runtime`][rt] includes:
|
|
//!
|
|
//! * A [reactor] to drive I/O resources.
|
|
//! * An [executor] to execute tasks that use these I/O resources.
|
|
//! * A [timer] for scheduling work to run after a set period of time.
|
|
//!
|
|
//! Note that [`current_thread::Runtime`][rt] does not implement `Send` itself
|
|
//! and cannot be safely moved to other threads.
|
|
//!
|
|
//! # Spawning from other threads
|
|
//!
|
|
//! While [`current_thread::Runtime`][rt] does not implement `Send` and cannot
|
|
//! safely be moved to other threads, it provides a `Handle` that can be sent
|
|
//! to other threads and allows to spawn new tasks from there.
|
|
//!
|
|
//! For example:
|
|
//!
|
|
//! ```
|
|
//! # extern crate tokio;
|
|
//! # extern crate futures;
|
|
//! use tokio::runtime::current_thread::Runtime;
|
|
//! use tokio::prelude::*;
|
|
//! use std::thread;
|
|
//!
|
|
//! # fn main() {
|
|
//! let mut runtime = Runtime::new().unwrap();
|
|
//! let handle = runtime.handle();
|
|
//!
|
|
//! thread::spawn(move || {
|
|
//! handle.spawn(future::ok(()));
|
|
//! }).join().unwrap();
|
|
//!
|
|
//! # /*
|
|
//! runtime.run().unwrap();
|
|
//! # */
|
|
//! # }
|
|
//! ```
|
|
//!
|
|
//! # Examples
|
|
//!
|
|
//! Creating a new `Runtime` and running a future `f` until its completion and
|
|
//! returning its result.
|
|
//!
|
|
//! ```
|
|
//! use tokio::runtime::current_thread::Runtime;
|
|
//! use tokio::prelude::*;
|
|
//!
|
|
//! let mut runtime = Runtime::new().unwrap();
|
|
//!
|
|
//! // Use the runtime...
|
|
//! // runtime.block_on(f); // where f is a future
|
|
//! ```
|
|
//!
|
|
//! [rt]: struct.Runtime.html
|
|
//! [concurrent-rt]: ../struct.Runtime.html
|
|
//! [chan]: https://docs.rs/futures/0.1/futures/sync/mpsc/fn.channel.html
|
|
|
|
mod builder;
|
|
mod runtime;
|
|
|
|
pub use self::builder::Builder;
|
|
pub use self::runtime::{Runtime, Handle};
|