Структура Runtime

Создаёт новый экземпляр среды выполнения со значениями конфигурации по умолчанию.

При этом инициализируются многопоточный планировщик, драйвер ввода-вывода и драйвер времени.

Большинству приложений не нужно вызывать эту функцию напрямую. Вместо этого они используют атрибут #[tokio::main]. Если требуется более сложная конфигурация, можно использовать построитель среды выполнения.

Подробнее см. в документации модуля.

Примеры

Создание нового Runtime со значениями конфигурации по умолчанию.

use tokio::runtime::Runtime;

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

// Use the runtime...

Возвращает дескриптор механизма запуска задач среды выполнения.

Возвращённый дескриптор можно использовать для запуска задач в этой среде выполнения, а также клонировать, чтобы передавать Handle в другие потоки.

Вызов Handle::block_on для дескриптора многопоточной среды выполнения current_thread может привести к ошибкам. Подробнее см. в документации к Handle::block_on.

Примеры

use tokio::runtime::Runtime;

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

let handle = rt.handle();

// Use the handle...

Запускает фьючер в среде выполнения Tokio.

Переданный фьючер запускается исполнителем среды выполнения, обычно пулом потоков. Затем пул потоков отвечает за опрос фьючера до его завершения.

Переданный фьючер начнёт выполняться в фоновом режиме сразу после вызова spawn, даже если вы не ожидаете возвращённый JoinHandle (при условии, что среда выполнения работает).

Подробнее см. в документации модуля.

Примеры

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");
});

Выполняет переданную функцию в исполнителе, предназначенном для блокирующих операций.

Примеры

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");
});

Выполняет фьючер до завершения в среде выполнения Tokio. Это точка входа в среду выполнения.

Переданный фьючер выполняется в текущем потоке, который блокируется до его завершения, после чего возвращается полученный результат. Все задачи и таймеры, которые фьючер запускает внутри себя, будут выполняться в среде выполнения.

Фьючер, не являющийся рабочей задачей

Обратите внимание, что фьючер, передаваемый этой функции, не выполняется как рабочая задача. Предполагается, что этот фьючер будет запускать другие задачи. Ожидание других фьючеров внутри переданного сюда фьючера будет выполняться не так быстро, как ожидание задач, запущенных в качестве рабочих.

Многопоточный планировщик

При использовании многопоточного планировщика фьючеры смогут выполняться в контексте драйвера ввода-вывода и таймера всей среды выполнения.

Все запущенные задачи продолжат выполняться после возврата block_on.

Однопоточный планировщик

Если включён однопоточный планировщик, block_on можно вызывать одновременно из нескольких потоков. Первый вызов получит во владение драйверы ввода-вывода и таймера. Это означает, что другие потоки, не владеющие драйверами, будут использовать их через этот поток. Когда первый вызов block_on завершится, другие потоки смогут «перехватить» драйвер, чтобы продолжить выполнение своих фьючеров.

Все запущенные задачи будут приостановлены после возврата block_on. Повторный вызов block_on возобновит ранее запущенные задачи.

Паника

Эта функция вызывает панику, если переданный фьючер вызывает панику или если функция вызвана в контексте асинхронного выполнения.

Примеры

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");
});

Входит в контекст среды выполнения.

Это позволяет создавать типы, которым при создании необходим доступный исполнитель, например Sleep или TcpStream. Это также позволит вызывать такие методы, как tokio::spawn.

Пример

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

fn function_that_spawns(msg: String) -> JoinHandle<()> {
    // 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();
    let handle = function_that_spawns(s);

    // Wait for the task before we end the test.
    rt.block_on(handle).unwrap();
}

Завершает работу среды выполнения, ожидая не более duration, пока все запущенные задачи не остановятся.

Дополнительные сведения см. в документации на уровне структуры.

Примеры

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));
}

Завершает работу среды выполнения, не ожидая остановки запущенных задач.

Это может быть полезно, если нужно удалить среду выполнения из другой среды выполнения. Обычно удаление среды выполнения бесконечно блокирует выполнение до завершения запущенных блокирующих задач, что, как правило, недопустимо в асинхронном контексте. Вызвав shutdown_background(), можно удалить среду выполнения из такого контекста.

Однако следует учитывать, что, поскольку мы не ожидаем завершения блокирующих задач, это может привести к утечке ресурсов (любые блокирующие задачи продолжат выполняться до своего завершения).

Дополнительные сведения см. в документации на уровне структуры.

Эта функция эквивалентна вызову shutdown_timeout(Duration::from_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();
   });
}

Возвращает представление, позволяющее получить сведения о производительности среды выполнения.

Возвращает аргумент без изменений.

Вызывает U::from(self).

То есть это преобразование выполняется так, как определяет реализация From<T> for U.