# [−] [src] Struct tokio::runtime::Runtime

    pub struct Runtime { /* fields omitted */ }

The Tokio runtime.

The runtime provides an I/O driver, task scheduler, timer, and blocking pool, necessary for running asynchronous tasks.

Instances of `Runtime` can be created using `new`, or `Builder`. However, most users will use the `#[tokio::main]` annotation on their entry point instead.

See module level documentation for more details.

# Shutdown

Shutting down the runtime is done by dropping the value. The current thread will block until the shut down operation has completed.

- Drain any scheduled work queues.
- Drop any futures that have not yet completed.
- Drop the reactor.

Once the reactor has dropped, any outstanding I/O resources bound to that reactor will no longer function. Calling any method on them will result in an error.

# Sharing

The Tokio runtime implements `Sync` and `Send` to allow you to wrap it in a `Arc`. Most fn take `&self` to allow you to call them concurrently accross multiple threads.

Calls to `shutdown` and `shutdown_timeout` require exclusive ownership of the runtime type and this can be achieved via `Arc::try_unwrap` when only one strong count reference is left over.

## Implementations

### `impl Runtime` [src]

#### `pub fn new() -> Result<Runtime>` [src]

Create a new runtime instance with default configuration values.

This results in the multi threaded scheduler, I/O driver, and time driver being initialized.

Most applications will not need to call this function directly. Instead, they will use the `#[tokio::main]` attribute. When a more complex configuration is necessary, the runtime builder may be used.

See module level documentation for more details.

# Examples

Creating a new `Runtime` with default configuration values.

    use tokio::runtime::Runtime;

    let rt = Runtime::new()
        .unwrap();

    // Use the runtime...

#### `pub fn handle(&self) -> &Handle` [src]

Return a handle to the runtime's spawner.

The returned handle can be used to spawn tasks that run on this runtime, and can be cloned to allow moving the `Handle` to other threads.

# Examples

    use tokio::runtime::Runtime;

    let rt = Runtime::new()
        .unwrap();

    let handle = rt.handle();

    // Use the handle...

#### `pub fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>ⓘ

### Notable traits for JoinHandle<T>

`impl<T> Future for JoinHandle<T> type Output = Result<T, JoinError>;`
where
F: Future + Send + 'static,
F::Output: Send + 'static,` [src]

Spawn a future onto the Tokio runtime.

This spawns the given future onto the runtime's executor, usually a thread pool. The thread pool is then responsible for polling the future until it completes.

See module level documentation for more details.

# Examples

    use tokio::runtime::Runtime;

    // Create the runtime
    let rt = Runtime::new().unwrap();

    // Spawn a future onto the runtime
    rt.spawn(async {
        println!("now running on a worker thread");
    });

#### `pub fn spawn_blocking<F, R>(&self, func: F) -> JoinHandle<R>ⓘ

### Notable traits for JoinHandle<T>

`impl<T> Future for JoinHandle<T> type Output = Result<T, JoinError>;`
where
F: FnOnce() -> R + Send + 'static,
R: Send + 'static,` [src]

Run the provided function on an executor dedicated to blocking operations.

# Examples

    use tokio::runtime::Runtime;

    // Create the runtime
    let rt = Runtime::new().unwrap();

    // Spawn a blocking function onto the runtime
    rt.spawn_blocking(|| {
        println!("now running on a worker thread");
    });

#### `pub fn block_on<F: Future>(&self, future: F) -> F::Output` [src]

Run a future to completion on the Tokio runtime. This is the runtime's entry point.

This runs the given future on the runtime, blocking until it is complete, and yielding its resolved result. Any tasks or timers which the future spawns internally will be executed on the runtime.

# Multi thread scheduler

When the multi thread scheduler is used this will allow futures to run within the io driver and timer context of the overall runtime.

# Current thread scheduler

When the current thread scheduler is enabled `block_on` can be called concurrently from multiple threads. The first call will take ownership of the io and timer drivers. This means other threads which do not own the drivers will hook into that one. When the first `block_on` completes, other threads will be able to "steal" the driver to allow continued execution of their futures.

# Panics

This function panics if the provided future panics, or if called within an asynchronous execution context.

# Examples

    use tokio::runtime::Runtime;

    // Create the runtime
    let rt  = Runtime::new().unwrap();

    // Execute the future, blocking the current thread until completion
    rt.block_on(async {
        println!("hello");
    });

#### `pub fn enter(&self) -> EnterGuard<'_>` [src]

Enter the runtime context.

This allows you to construct types that must have an executor available on creation such as `Sleep` or `TcpStream`. It will also allow you to call methods such as `tokio::spawn`.

# Example

    use tokio::runtime::Runtime;

    fn function_that_spawns(msg: String) {
        // Had we not used `rt.enter` below, this would panic.
        tokio::spawn(async move {
            println!("{}", msg);
        });
    }

    fn main() {
        let rt = Runtime::new().unwrap();

        let s = "Hello World!".to_string();

        // By entering the context, we tie `tokio::spawn` to this executor.
        let _guard = rt.enter();
        function_that_spawns(s);
    }

#### `pub fn shutdown_timeout(self, duration: Duration)` [src]

Shutdown the runtime, waiting for at most `duration` for all spawned task to shutdown.

Usually, dropping a `Runtime` handle is sufficient as tasks are able to shutdown in a timely fashion. However, dropping a `Runtime` will wait indefinitely for all tasks to terminate, and there are cases where a long blocking task has been spawned, which can block dropping `Runtime`.

In this case, calling `shutdown_timeout` with an explicit wait timeout can work. The `shutdown_timeout` will signal all tasks to shutdown and will wait for at most `duration` for all spawned tasks to terminate. If `timeout` elapses before all tasks are dropped, the function returns and outstanding tasks are potentially leaked.

# Examples

    use tokio::runtime::Runtime;
    use tokio::task;

    use std::thread;
    use std::time::Duration;

    fn main() {
       let runtime = Runtime::new().unwrap();

       runtime.block_on(async move {
           task::spawn_blocking(move || {
               thread::sleep(Duration::from_secs(10_000));
           });
       });

       runtime.shutdown_timeout(Duration::from_millis(100));
    }

#### `pub fn shutdown_background(self)` [src]

Shutdown the runtime, without waiting for any spawned tasks to shutdown.

This can be useful if you want to drop a runtime from within another runtime. Normally, dropping a runtime will block indefinitely for spawned blocking tasks to complete, which would normally not be permitted within an asynchronous context. By calling `shutdown_background()`, you can drop the runtime from such a context.

Note however, that because we do not wait for any blocking tasks to complete, this may result in a resource leak (in that any blocking tasks are still running until they return.

This function is equivalent to calling `shutdown_timeout(Duration::of_nanos(0))`.

    use tokio::runtime::Runtime;

    fn main() {
       let runtime = Runtime::new().unwrap();

       runtime.block_on(async move {
           let inner_runtime = Runtime::new().unwrap();
           // ...
           inner_runtime.shutdown_background();
       });
    }

## Trait Implementations

### `impl Debug for Runtime` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl !RefUnwindSafe for Runtime`

### `impl Send for Runtime`

### `impl Sync for Runtime`

### `impl Unpin for Runtime`

### `impl !UnwindSafe for Runtime`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.