Что такое Tokio и какую проблему он решает в Rust?

Question

Accepted Answer

Что такое Tokio

Tokio — это асинхронный runtime для Rust, реализующий цикл событий (event loop) поверх epoll (Linux), kqueue (macOS) и IOCP (Windows). Он состоит из трёх слоёв:

Reactor — слушает события ОС (сокеты готовы к чтению/записи) и пробуждает нужные Future.
Executor (scheduler) — работает на пуле OS-потоков (work-stealing) и раскручивает Future до следующей точки ожидания.
Экосистема — tokio::net, tokio::time, tokio::sync, tokio::fs: готовые async-примитивы поверх runtime.

Какую проблему решает

Rust без runtime поддерживает синтаксис async/await, но компилятор генерирует лишь конечный автомат (Future) — выполнять его некому. Tokio предоставляет этого «исполнителя». Альтернатива без async — один поток на соединение (модель Apache), что при 10 000 одновременных клиентов означает 10 000 OS-потоков и сотни МБ стека. Tokio мультиплексирует тысячи задач на небольшом пуле потоков (по умолчанию равном числу CPU), экономя память и избегая context switch OS.

Практический пример

HTTP-сервер, принимающий соединения и отвечающий за 1 мс:

use tokio::net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]  // разворачивается в Runtime::new().block_on(...)
async fn main() -> anyhow::Result<()> {
    let listener = TcpListener::bind("0.0.0.0:8080").await?;
    println!("Listening on :8080");

    loop {
        let (mut socket, addr) = listener.accept().await?;
        // tokio::spawn порождает лёгкую задачу (green thread),
        // НЕ OS-поток — стек ~2 KB вместо ~8 MB
        tokio::spawn(async move {
            let mut buf = vec![0u8; 1024];
            match socket.read(&mut buf).await {
                Ok(0) => return,  // соединение закрыто
                Ok(n) => {
                    println!("Got {} bytes from {}", n, addr);
                    let response = b"HTTP/1.1 200 OK
Content-Length: 5

hello";
                    let _ = socket.write_all(response).await;
                }
                Err(e) => eprintln!("read error: {}", e),
            }
        });
    }
}

Ключевые моменты: #[tokio::main] запускает многопоточный runtime; tokio::spawn — неблокирующий запуск задачи; .await — точка, где executor передаёт управление другим задачам.

Многопоточный vs однопоточный runtime

Tokio предлагает два режима:

#[tokio::main] — multi_thread по умолчанию, N рабочих потоков (N = CPU).
#[tokio::main(flavor = "current_thread")] — один поток, полезен для тестов и встраиваемых систем.

// Явная конфигурация runtime
let rt = tokio::runtime::Builder::new_multi_thread()
    .worker_threads(4)
    .enable_all()
    .build()?;
rt.block_on(async { /* ... */ });

Подводные камни

Блокирующий код в async-контексте. Вызов std::thread::sleep или синхронного I/O внутри async блокирует весь рабочий поток executor, заморозив все задачи на нём. Решение: tokio::time::sleep для таймеров, tokio::task::spawn_blocking для CPU-heavy и синхронного кода.
Паника в spawned task молча проглатывается. tokio::spawn возвращает JoinHandle; если его не .await-ить, паника потеряется. Всегда обрабатывайте JoinHandle::await или логируйте ошибки.
Отсутствие Send у Future. Multi-thread runtime требует, чтобы задачи реализовывали Send. Хранение Rc, RefCell или сырых указателей через точку .await вызовет ошибку компилятора.
Неправильный выбор канала. tokio::sync::Mutex нельзя удерживать через .await если используется std Mutex (deadlock). Нужен именно tokio::sync::Mutex для async контекстов.
Пропущенный enable_all(). При ручной сборке runtime без .enable_all() или .enable_io().enable_time() — TCP-сокеты и таймеры не работают (panic в runtime).
Task cancellation и утечки ресурсов. Когда JoinHandle дропается, задача отменяется при следующем .await. Деструкторы вызываются, но если ресурс освобождается после последней точки .await, cleanup не выполнится. Используйте tokio::select! с явными ветками отмены.
Вложенные runtime. Вызов Runtime::block_on внутри уже работающего Tokio runtime вызывает panic. При интеграции синхронного и async кода используйте Handle::current().block_on() или spawn_blocking.
Версионная несовместимость. Tokio 0.x и Tokio 1.x несовместимы на уровне типов. Если зависимость тянет tokio 0.2, а ваш код использует tokio 1.x, компилятор выдаст ошибки несовпадения типов для Future.

Что такое Tokio и какую проблему он решает в Rust?