Горячие клавиши

Нажмите ← или → для навигации между главами

Нажмите S или / для поиска по книге

Нажмите ? для показа этой справки

Нажмите Esc для скрытия этой справки

Передача управления среде выполнения

Вспомните из раздела «Наша первая асинхронная программа», что в каждой точке await Rust даёт среде выполнения возможность приостановить задачу и переключиться на другую, если ожидаемый фьючерс не готов. Обратное также верно: Rust только приостанавливает асинхронные блоки и возвращает управление среде выполнения в точке await. Всё между точками await является синхронным.

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

Давайте смоделируем длительную операцию, чтобы проиллюстрировать проблему голодания, а затем исследуем, как её решить. Листинг 17-14 вводит функцию slow.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::{thread, time::Duration};

fn main() {
    trpl::block_on(async {
        // Позже мы вызовем `slow` здесь
    });
}

fn slow(name: &str, ms: u64) {
    thread::sleep(Duration::from_millis(ms));
    println!("'{name}' ran for {ms}ms");
}
Листинг 17-14: Использование thread::sleep для имитации медленных операций

Этот код использует std::thread::sleep вместо trpl::sleep, так что вызов slow заблокирует текущий поток на некоторое количество миллисекунд. Мы можем использовать slow, чтобы заменить реальные операции, которые одновременно являются длительными и блокирующими.

В листинге 17-15 мы используем slow, чтобы имитировать выполнение такой работы, привязанной к процессору, в паре фьючерсов.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::{thread, time::Duration};

fn main() {
    trpl::block_on(async {
        let a = async {
            println!("'a' started.");
            slow("a", 30);
            slow("a", 10);
            slow("a", 20);
            trpl::sleep(Duration::from_millis(50)).await;
            println!("'a' finished.");
        };

        let b = async {
            println!("'b' started.");
            slow("b", 75);
            slow("b", 10);
            slow("b", 15);
            slow("b", 350);
            trpl::sleep(Duration::from_millis(50)).await;
            println!("'b' finished.");
        };

        trpl::select(a, b).await;
    });
}

fn slow(name: &str, ms: u64) {
    thread::sleep(Duration::from_millis(ms));
    println!("'{name}' ran for {ms}ms");
}
Листинг 17-15: Вызов функции slow для имитации медленных операций

Каждый фьючерс передаёт управление среде выполнения только после выполнения множества медленных операций. Если вы запустите этот код, вы увидите следующий вывод:

'a' started.
'a' ran for 30ms
'a' ran for 10ms
'a' ran for 20ms
'b' started.
'b' ran for 75ms
'b' ran for 10ms
'b' ran for 15ms
'b' ran for 350ms
'a' finished.

Как и в листинге 17-5, где мы использовали trpl::select для гонки фьючерсов, загружающих два URL-адреса, select всё равно завершается, как только a готов. Однако между вызовами slow в двух фьючерсах нет чередования. Фьючерс a выполняет всю свою работу, пока не будет ожидаться вызов trpl::sleep, затем фьючерс b выполняет всю свою работу, пока не будет ожидаться его собственный вызов trpl::sleep, и наконец фьючерс a завершается. Чтобы позволить обоим фьючерсам продвигаться между их медленными задачами, нам нужны точки await, чтобы мы могли передать управление обратно среде выполнения. Это означает, что нам нужно что-то, что мы можем ожидать!

Мы уже можем видеть этот вид передачи управления в листинге 17-15: если бы мы удалили trpl::sleep в конце фьючерса a, он завершился бы без какого-либо запуска фьючерса b. Давайте попробуем использовать функцию trpl::sleep в качестве отправной точки для того, чтобы позволить операциям переключаться с продвижения, как показано в листинге 17-16.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::{thread, time::Duration};

fn main() {
    trpl::block_on(async {
        let one_ms = Duration::from_millis(1);

        let a = async {
            println!("'a' started.");
            slow("a", 30);
            trpl::sleep(one_ms).await;
            slow("a", 10);
            trpl::sleep(one_ms).await;
            slow("a", 20);
            trpl::sleep(one_ms).await;
            println!("'a' finished.");
        };

        let b = async {
            println!("'b' started.");
            slow("b", 75);
            trpl::sleep(one_ms).await;
            slow("b", 10);
            trpl::sleep(one_ms).await;
            slow("b", 15);
            trpl::sleep(one_ms).await;
            slow("b", 350);
            trpl::sleep(one_ms).await;
            println!("'b' finished.");
        };

        trpl::select(a, b).await;
    });
}

fn slow(name: &str, ms: u64) {
    thread::sleep(Duration::from_millis(ms));
    println!("'{name}' ran for {ms}ms");
}
Листинг 17-16: Использование trpl::sleep, чтобы позволить операциям переключаться с продвижения

Мы добавили вызовы trpl::sleep с точками await между каждым вызовом slow. Теперь работа двух фьючерсов чередуется:

'a' started.
'a' ran for 30ms
'b' started.
'b' ran for 75ms
'a' ran for 10ms
'b' ran for 10ms
'a' ran for 20ms
'b' ran for 15ms
'a' finished.

Фьючерс a всё ещё выполняется немного перед передачей управления b, потому что он вызывает slow до первого вызова trpl::sleep, но после этого фьючерсы меняются туда-сюда каждый раз, когда один из них достигает точки await. В этом случае мы сделали это после каждого вызова slow, но мы могли бы разбить работу любым способом, который имеет наибольший смысл для нас.

Однако мы на самом деле не хотим спать здесь: мы хотим продвигаться как можно быстрее. Нам просто нужно передать управление обратно среде выполнения. Мы можем сделать это напрямую, используя функцию trpl::yield_now. В листинге 17-17 мы заменяем все эти вызовы trpl::sleep на trpl::yield_now.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::{thread, time::Duration};

fn main() {
    trpl::block_on(async {
        let a = async {
            println!("'a' started.");
            slow("a", 30);
            trpl::yield_now().await;
            slow("a", 10);
            trpl::yield_now().await;
            slow("a", 20);
            trpl::yield_now().await;
            println!("'a' finished.");
        };

        let b = async {
            println!("'b' started.");
            slow("b", 75);
            trpl::yield_now().await;
            slow("b", 10);
            trpl::yield_now().await;
            slow("b", 15);
            trpl::yield_now().await;
            slow("b", 350);
            trpl::yield_now().await;
            println!("'b' finished.");
        };

        trpl::select(a, b).await;
    });
}

fn slow(name: &str, ms: u64) {
    thread::sleep(Duration::from_millis(ms));
    println!("'{name}' ran for {ms}ms");
}
Листинг 17-17: Использование yield_now, чтобы позволить операциям переключаться с продвижения

Этот код яснее передаёт реальное намерение и может быть значительно быстрее, чем использование sleep, потому что таймеры, такие как используемый sleep, часто имеют ограничения на гранулярность. Используемая нами версия sleep, например, всегда будет спать не менее миллисекунды, даже если мы передадим ей Duration в одну наносекунду. Опять же, современные компьютеры быстры: они могут сделать много за одну миллисекунду!

Это означает, что async может быть полезен даже для задач, привязанных к процессору, в зависимости от того, что ещё делает ваша программа, потому что он предоставляет полезный инструмент для структурирования связей между различными частями программы (но ценой накладных расходов асинхронного конечного автомата). Это форма кооперативной многозадачности, где каждый фьючерс имеет власть определять, когда он передаёт управление через точки await. Поэтому каждый фьючерс также несёт ответственность за то, чтобы не блокировать слишком долго. В некоторых встроенных операционных системах на основе Rust это единственный вид многозадачности!

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

Создание наших собственных асинхронных абстракций

Мы также можем компоновать фьючерсы вместе, чтобы создавать новые паттерны. Например, мы можем построить функцию timeout из асинхронных строительных блоков, которые у нас уже есть. Когда мы закончим, результатом будет ещё один строительный блок, который мы могли бы использовать для создания ещё большего количества асинхронных абстракций.

Листинг 17-18 показывает, как мы ожидаем, что этот timeout будет работать с медленным фьючерсом.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let slow = async {
            trpl::sleep(Duration::from_secs(5)).await;
            "Finally finished"
        };

        match timeout(slow, Duration::from_secs(2)).await {
            Ok(message) => println!("Succeeded with '{message}'"),
            Err(duration) => {
                println!("Failed after {} seconds", duration.as_secs())
            }
        }
    });
}
Листинг 17-18: Использование нашего воображаемого timeout для запуска медленной операции с ограничением по времени

Давайте реализуем это! Для начала давайте подумаем об API для timeout:

  • Он должен сам быть асинхронной функцией, чтобы мы могли его ожидать.
  • Его первый параметр должен быть фьючерсом для запуска. Мы можем сделать его обобщённым, чтобы он работал с любым фьючерсом.
  • Его второй параметр будет максимальным временем ожидания. Если мы используем Duration, это облегчит передачу его в trpl::sleep.
  • Он должен возвращать Result. Если фьючерс завершается успешно, Result будет Ok со значением, произведённым фьючерсом. Если тайм-аут истекает первым, Result будет Err с продолжительностью, которую тайм-аут ожидал.

Листинг 17-19 показывает это объявление.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let slow = async {
            trpl::sleep(Duration::from_secs(5)).await;
            "Finally finished"
        };

        match timeout(slow, Duration::from_secs(2)).await {
            Ok(message) => println!("Succeeded with '{message}'"),
            Err(duration) => {
                println!("Failed after {} seconds", duration.as_secs())
            }
        }
    });
}

async fn timeout<F: Future>(
    future_to_try: F,
    max_time: Duration,
) -> Result<F::Output, Duration> {
    // Здесь будет наша реализация!
}
Листинг 17-19: Определение сигнатуры timeout

Это удовлетворяет нашим целям для типов. Теперь давайте подумаем о поведении, которое нам нужно: мы хотим устроить гонку между переданным фьючерсом и продолжительностью. Мы можем использовать trpl::sleep, чтобы создать фьючерс-таймер из продолжительности, и использовать trpl::select, чтобы запустить этот таймер с фьючерсом, который передал вызывающий код.

В листинге 17-20 мы реализуем timeout, сопоставляя с результатом ожидания trpl::select.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::time::Duration;

use trpl::Either;

// --snip--

fn main() {
    trpl::block_on(async {
        let slow = async {
            trpl::sleep(Duration::from_secs(5)).await;
            "Finally finished"
        };

        match timeout(slow, Duration::from_secs(2)).await {
            Ok(message) => println!("Succeeded with '{message}'"),
            Err(duration) => {
                println!("Failed after {} seconds", duration.as_secs())
            }
        }
    });
}

async fn timeout<F: Future>(
    future_to_try: F,
    max_time: Duration,
) -> Result<F::Output, Duration> {
    match trpl::select(future_to_try, trpl::sleep(max_time)).await {
        Either::Left(output) => Ok(output),
        Either::Right(_) => Err(max_time),
    }
}
Листинг 17-20: Определение timeout с помощью select и sleep

Реализация trpl::select не является справедливой: она всегда опрашивает аргументы в том порядке, в котором они переданы (другие реализации select будут случайным образом выбирать, какой аргумент опрашивать первым). Таким образом, мы передаём future_to_try в select первым, чтобы у него был шанс завершиться, даже если max_time — очень короткая продолжительность. Если future_to_try завершается первым, select вернёт Left с выводом от future_to_try. Если timer завершается первым, select вернёт Right с выводом таймера ().

Если future_to_try завершается успешно и мы получаем Left(output), мы возвращаем Ok(output). Если вместо этого истекает таймер сна и мы получаем Right(()), мы игнорируем () с помощью _ и возвращаем Err(max_time).

С этим у нас есть работающий timeout, построенный из двух других асинхронных помощников. Если мы запустим наш код, он выведет режим отказа после тайм-аута:

Failed after 2 seconds

Поскольку фьючерсы компонуются с другими фьючерсами, вы можете создавать действительно мощные инструменты, используя меньшие асинхронные строительные блоки. Например, вы можете использовать тот же подход, чтобы комбинировать тайм-ауты с повторными попытками, а затем использовать их с такими операциями, как сетевые вызовы (например, те, что в листинге 17-5).

На практике вы обычно будете работать напрямую с async и await, а во вторую очередь — с такими функциями, как select, и макросами, такими как макрос join!, чтобы управлять тем, как выполняются внешние фьючерсы.

Теперь мы увидели ряд способов работы с несколькими фьючерсами одновременно. Далее мы рассмотрим, как мы можем работать с несколькими фьючерсами в последовательности во времени с помощью стримов.