Фьючерсы и синтаксис async
Ключевыми элементами асинхронного программирования в Rust являются фьючерсы и ключевые слова async и await.
Фьючерс — это значение, которое может быть не готово сейчас, но станет готово в какой-то момент в будущем. (Та же концепция появляется во многих языках, иногда под другими именами, такими как задача или обещание.) Rust предоставляет трейт Future в качестве строительного блока, чтобы различные асинхронные операции могли быть реализованы с помощью различных структур данных, но с общим интерфейсом. В Rust фьючерсы — это типы, которые реализуют трейт Future. Каждый фьючерс хранит свою собственную информацию о достигнутом прогрессе и о том, что означает «готово».
Вы можете применить ключевое слово async к блокам и функциям, чтобы указать, что они могут быть прерваны и возобновлены. Внутри асинхронного блока или асинхронной функции вы можете использовать ключевое слово await, чтобы ожидать фьючерс (то есть ждать, пока он станет готовым). Любая точка, где вы ожидаете фьючерс внутри асинхронного блока или функции, — это потенциальное место для приостановки и возобновления этого блока или функции. Процесс проверки фьючерса на предмет того, доступно ли его значение, называется опросом (polling).
Некоторые другие языки, такие как C# и JavaScript, также используют ключевые слова async и await для асинхронного программирования. Если вы знакомы с этими языками, вы можете заметить некоторые существенные различия в том, как Rust обрабатывает синтаксис. И на это есть веские причины, как мы увидим!
При написании асинхронного кода на Rust мы большую часть времени используем ключевые слова async и await. Rust компилирует их в эквивалентный код с использованием трейта Future, точно так же, как он компилирует циклы for в эквивалентный код с использованием трейта Iterator. Однако, поскольку Rust предоставляет трейт Future, вы также можете реализовать его для своих собственных типов данных, когда вам это нужно. Многие функции, которые мы увидим в этой главе, возвращают типы с собственными реализациями Future. Мы вернёмся к определению трейта в конце главы и подробнее разберём, как он работает, но этих деталей достаточно, чтобы двигаться вперёд.
Всё это может показаться немного абстрактным, поэтому давайте напишем нашу первую асинхронную программу: небольшой веб-скрапер. Мы передадим два URL-адреса из командной строки, конкурентно извлечём их оба и вернём результат того, который завершится первым. В этом примере будет довольно много нового синтаксиса, но не волнуйтесь — мы объясним всё, что вам нужно знать, по ходу дела.
Наша первая асинхронная программа
Чтобы сосредоточить главу на изучении async, а не на жонглировании частями экосистемы, мы создали крейт trpl (trpl — сокращение от «The Rust Programming Language»). Он реэкспортирует все типы, трейты и функции, которые вам понадобятся, в первую очередь из крейтов futures и tokio. Крейт futures — официальный дом для экспериментов с асинхронным кодом на Rust, и именно там изначально был спроектирован трейт Future. Tokio — это наиболее широко используемый асинхронный рантайм в Rust на сегодняшний день, особенно для веб-приложений. Есть и другие отличные рантаймы, и они могут быть более подходящими для ваших целей. Мы используем крейт tokio под капотом trpl, потому что он хорошо протестирован и широко используется.
В некоторых случаях trpl также переименовывает или оборачивает оригинальные API, чтобы сосредоточить ваше внимание на деталях, относящихся к этой главе. Если вы хотите понять, что делает крейт, мы рекомендуем вам ознакомиться с его исходным кодом. Вы сможете увидеть, из какого крейта происходит каждый реэкспорт, и мы оставили подробные комментарии, объясняющие, что делает крейт.
Создайте новый бинарный проект с именем hello-async и добавьте крейт trpl в качестве зависимости:
$ cargo new hello-async
$ cd hello-async
$ cargo add trpl
Теперь мы можем использовать различные части, предоставляемые trpl, чтобы написать нашу первую асинхронную программу. Мы создадим небольшой инструмент командной строки, который извлекает две веб-страницы, извлекает элемент <title> из каждой и печатает заголовок той страницы, которая завершит весь этот процесс первой.
Определение функции page_title
Давайте начнём с написания функции, которая принимает один URL страницы в качестве параметра, делает запрос к нему и возвращает текст элемента <title> (см. Листинг 17-1).
extern crate trpl; // required for mdbook test
fn main() {
// TODO: добавим это следующим шагом!
}
use trpl::Html;
async fn page_title(url: &str) -> Option<String> {
let response = trpl::get(url).await;
let response_text = response.text().await;
Html::parse(&response_text)
.select_first("title")
.map(|title| title.inner_html())
}
<title> с HTML-страницыСначала мы определяем функцию с именем page_title и помечаем её ключевым словом async. Затем мы используем функцию trpl::get, чтобы получить любой переданный URL, и добавляем ключевое слово await, чтобы дождаться ответа. Чтобы получить текст response, мы вызываем его метод text и снова ожидаем его с помощью ключевого слова await. Оба этих шага асинхронны. Для функции get нам нужно дождаться, пока сервер отправит обратно первую часть своего ответа, которая будет включать HTTP-заголовки, cookie и так далее, и может быть доставлена отдельно от тела ответа. Особенно если тело очень большое, может потребоваться некоторое время, чтобы всё оно прибыло. Поскольку нам нужно дождаться всего ответа, метод text также асинхронный.
Мы должны явно ожидать оба этих фьючерса, потому что фьючерсы в Rust ленивы: они ничего не делают, пока вы не попросите их с помощью ключевого слова await. (На самом деле, Rust выдаст предупреждение компилятора, если вы не используете фьючерс.) Это может напомнить вам обсуждение итераторов в разделе «Обработка последовательности элементов с помощью итераторов» главы 13. Итераторы ничего не делают, пока вы не вызовете их метод next — напрямую или с помощью циклов for или методов, таких как map, которые используют next под капотом. Точно так же фьючерсы ничего не делают, пока вы явно их не попросите. Эта ленивость позволяет Rust избегать выполнения асинхронного кода, пока он действительно не понадобится.
Примечание: Это отличается от поведения, которое мы видели при использовании thread::spawn в разделе «Создание нового потока с помощью spawn» главы 16, где замыкание, которое мы передали другому потоку, начинало выполняться немедленно. Это также отличается от того, как многие другие языки подходят к async. Но для Rust важно иметь возможность предоставлять свои гарантии производительности, так же как и с итераторами.
Как только у нас есть response_text, мы можем разобрать его в экземпляр типа Html с помощью Html::parse. Вместо необработанной строки у нас теперь есть тип данных, который мы можем использовать для работы с HTML как с более богатой структурой данных. В частности, мы можем использовать метод select_first, чтобы найти первое вхождение заданного CSS-селектора. Передав строку "title", мы получим первый элемент <title> в документе, если он есть. Поскольку соответствующего элемента может не быть, select_first возвращает Option<ElementRef>. Наконец, мы используем метод Option::map, который позволяет нам работать с элементом в Option, если он присутствует, и ничего не делать, если его нет. (Мы также могли бы использовать здесь выражение match, но map более идиоматичен.) В теле функции, которую мы передаём в map, мы вызываем inner_html у title, чтобы получить его содержимое, которое является String. В конечном итоге у нас есть Option<String>.
Обратите внимание, что ключевое слово await в Rust ставится после выражения, которого вы ожидаете, а не перед ним. То есть это постфиксное ключевое слово. Это может отличаться от того, к чему вы привыкли, если вы использовали async в других языках, но в Rust это делает цепочки методов гораздо более удобными для работы. В результате мы могли бы изменить тело page_title, чтобы объединить вызовы функций trpl::get и text с await между ними, как показано в листинге 17-2.
extern crate trpl; // required for mdbook test
use trpl::Html;
fn main() {
// TODO: добавим это следующим шагом!
}
async fn page_title(url: &str) -> Option<String> {
let response_text = trpl::get(url).await.text().await;
Html::parse(&response_text)
.select_first("title")
.map(|title| title.inner_html())
}
awaitС этим мы успешно написали нашу первую асинхронную функцию! Прежде чем мы добавим некоторый код в main, чтобы вызвать её, давайте немного поговорим о том, что мы написали и что это значит.
Когда Rust видит блок, помеченный ключевым словом async, он компилирует его в уникальный анонимный тип данных, который реализует трейт Future. Когда Rust видит функцию, помеченную async, он компилирует её в неасинхронную функцию, тело которой является асинхронным блоком. Тип возвращаемого значения асинхронной функции — это тип анонимного типа данных, который компилятор создаёт для этого асинхронного блока.
Таким образом, написание async fn эквивалентно написанию функции, которая возвращает фьючерс возвращаемого типа. Для компилятора определение функции, такое как async fn page_title в листинге 17-1, примерно эквивалентно неасинхронной функции, определённой следующим образом:
#![allow(unused)]
fn main() {
extern crate trpl; // required for mdbook test
use std::future::Future;
use trpl::Html;
fn page_title(url: &str) -> impl Future<Output = Option<String>> {
async move {
let text = trpl::get(url).await.text().await;
Html::parse(&text)
.select_first("title")
.map(|title| title.inner_html())
}
}
}
Давайте пройдёмся по каждой части преобразованной версии:
- Она использует синтаксис
impl Trait, который мы обсуждали в главе 10 в разделе «Трейты как параметры». - Возвращаемое значение реализует трейт
Futureсо связанным типомOutput. Обратите внимание, что типOutput— этоOption<String>, который совпадает с оригинальным возвращаемым типом из версииasync fnфункцииpage_title. - Весь код, вызываемый в теле оригинальной функции, обёрнут в блок
async move. Помните, что блоки — это выражения. Весь этот блок — это выражение, возвращаемое из функции. - Этот асинхронный блок создаёт значение с типом
Option<String>, как только что было описано. Это значение соответствует типуOutputв возвращаемом типе. Это точно так же, как и другие блоки, которые вы видели. - Тело новой функции — это блок
async moveиз-за того, как он использует параметрurl. (Мы поговорим гораздо больше оasyncпротивasync moveпозже в главе.)
Теперь мы можем вызвать page_title в main.
Выполнение асинхронной функции с помощью рантайма
Для начала мы получим заголовок одной страницы, как показано в листинге 17-3. К сожалению, этот код ещё не компилируется.
extern crate trpl; // required for mdbook test
use trpl::Html;
async fn main() {
let args: Vec<String> = std::env::args().collect();
let url = &args[1];
match page_title(url).await {
Some(title) => println!("The title for {url} was {title}"),
None => println!("{url} had no title"),
}
}
async fn page_title(url: &str) -> Option<String> {
let response_text = trpl::get(url).await.text().await;
Html::parse(&response_text)
.select_first("title")
.map(|title| title.inner_html())
}
page_title из main с аргументом, предоставленным пользователемМы следуем тому же шаблону, который использовали для получения аргументов командной строки в разделе «Приём аргументов командной строки» главы 12. Затем мы передаём аргумент URL в page_title и ожидаем результат. Поскольку значение, создаваемое фьючерсом, — это Option<String>, мы используем выражение match, чтобы напечатать разные сообщения в зависимости от того, был ли у страницы <title>.
Единственное место, где мы можем использовать ключевое слово await, — это асинхронные функции или блоки, и Rust не позволит нам пометить специальную функцию main как async.
error[E0752]: `main` function is not allowed to be `async`
--> src/main.rs:6:1
|
6 | async fn main() {
| ^^^^^^^^^^^^^^^ `main` function is not allowed to be `async`
Причина, по которой main нельзя помечать как async, заключается в том, что асинхронному коду нужен рантайм: крейт Rust, который управляет деталями выполнения асинхронного кода. Функция main программы может инициализировать рантайм, но она не является рантаймом сама по себе. (Мы увидим больше о том, почему это так, чуть позже.) Каждая программа на Rust, которая выполняет асинхронный код, имеет как минимум одно место, где она настраивает рантайм, который выполняет фьючерсы.
Большинство языков, поддерживающих async, включают рантайм в комплект, но Rust — нет. Вместо этого есть много различных доступных асинхронных рантаймов, каждый из которых делает разные компромиссы, подходящие для варианта использования, на который он нацелен. Например, высокопроизводительный веб-сервер с множеством ядер CPU и большим объёмом RAM имеет совершенно иные потребности, чем микроконтроллер с одним ядром, небольшим объёмом RAM и без возможности выделения памяти в куче. Крейты, которые предоставляют эти рантаймы, также часто поставляют асинхронные версии общей функциональности, такой как файловый или сетевой ввод-вывод.
Здесь и на протяжении всей остальной части главы мы будем использовать функцию block_on из крейта trpl, которая принимает фьючерс в качестве аргумента и блокирует текущий поток до тех пор, пока этот фьючерс не выполнится до завершения. Под капотом вызов block_on настраивает рантайм с использованием крейта tokio, который используется для выполнения переданного фьючерса (поведение block_on в крейте trpl аналогично функциям block_on других крейтов рантаймов). Как только фьючерс завершается, block_on возвращает то значение, которое создал фьючерс.
Мы могли бы передать фьючерс, возвращаемый page_title, непосредственно в block_on и, как только он завершится, сопоставить полученный Option<String>, как мы пытались сделать в листинге 17-3. Однако для большинства примеров в главе (и для большей части асинхронного кода в реальном мире) мы будем делать больше, чем просто один вызов асинхронной функции, поэтому вместо этого мы передадим асинхронный блок и явно ожидаем результат вызова page_title, как в листинге 17-4.
extern crate trpl; // required for mdbook test
use trpl::Html;
fn main() {
let args: Vec<String> = std::env::args().collect();
trpl::block_on(async {
let url = &args[1];
match page_title(url).await {
Some(title) => println!("The title for {url} was {title}"),
None => println!("{url} had no title"),
}
})
}
async fn page_title(url: &str) -> Option<String> {
let response_text = trpl::get(url).await.text().await;
Html::parse(&response_text)
.select_first("title")
.map(|title| title.inner_html())
}
trpl::block_onКогда мы запускаем этот код, мы получаем поведение, которое изначально ожидали:
$ cargo run -- "https://www.rust-lang.org"
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.05s
Running `target/debug/async_await 'https://www.rust-lang.org'`
The title for https://www.rust-lang.org was
Rust Programming Language
Уф — наконец-то у нас есть работающий асинхронный код! Но прежде чем мы добавим код, чтобы устроить гонку между двумя сайтами, давайте ненадолго вернём наше внимание к тому, как работают фьючерсы.
Каждая точка await — то есть каждое место, где код использует ключевое слово await, — представляет собой место, где управление возвращается рантайму. Чтобы это работало, Rust должен отслеживать состояние, задействованное в асинхронном блоке, так чтобы рантайм мог запустить некоторую другую работу, а затем вернуться, когда будет готов снова попытаться продвинуть первый. Это невидимая машина состояний, как если бы вы написали перечисление, подобное этому, чтобы сохранить текущее состояние в каждой точке await:
#![allow(unused)]
fn main() {
extern crate trpl; // required for mdbook test
enum PageTitleFuture<'a> {
Initial { url: &'a str },
GetAwaitPoint { url: &'a str },
TextAwaitPoint { response: trpl::Response },
}
}
Написание кода для перехода между каждым состоянием вручную было бы утомительным и подверженным ошибкам, однако, особенно когда вам нужно добавить больше функциональности и больше состояний в код позже. К счастью, компилятор Rust автоматически создаёт и управляет структурами данных машины состояний для асинхронного кода. Обычные правила заимствования и владения вокруг структур данных по-прежнему применяются, и, к счастью, компилятор также проверяет их за нас и предоставляет полезные сообщения об ошибках. Мы разберём некоторые из них позже в главе.
В конечном итоге что-то должно выполнять эту машину состояний, и это что-то — рантайм. (Вот почему вы можете встретить упоминания исполнителей при изучении рантаймов: исполнитель — это часть рантайма, ответственная за выполнение асинхронного кода.)
Теперь вы можете понять, почему компилятор остановил нас от того, чтобы сделать main самой асинхронной функцией в листинге 17-3. Если бы main была асинхронной функцией, что-то другое должно было бы управлять машиной состояний для любого фьючерса, возвращаемого main, но main — это отправная точка программы! Вместо этого мы вызвали функцию trpl::block_on в main, чтобы настроить рантайм и выполнить фьючерс, возвращаемый асинхронным блоком, до его завершения.
Примечание: Некоторые рантаймы предоставляют макросы, так что вы можете написать асинхронную функцию main. Эти макросы переписывают async fn main() { ... } в обычную fn main, которая делает то же, что мы сделали вручную в листинге 17-4: вызывает функцию, которая выполняет фьючерс до завершения так же, как это делает trpl::block_on.
Теперь давайте соберём эти части вместе и посмотрим, как мы можем написать конкурентный код.
Гонка двух URL-адресов друг с другом конкурентно
В листинге 17-5 мы вызываем page_title с двумя разными URL-адресами, переданными из командной строки, и устраиваем гонку между ними, выбирая тот фьючерс, который завершится первым.
extern crate trpl; // required for mdbook test
use trpl::{Either, Html};
fn main() {
let args: Vec<String> = std::env::args().collect();
trpl::block_on(async {
let title_fut_1 = page_title(&args[1]);
let title_fut_2 = page_title(&args[2]);
let (url, maybe_title) =
match trpl::select(title_fut_1, title_fut_2).await {
Either::Left(left) => left,
Either::Right(right) => right,
};
println!("{url} returned first");
match maybe_title {
Some(title) => println!("Its page title was: '{title}'"),
None => println!("It had no title."),
}
})
}
async fn page_title(url: &str) -> (&str, Option<String>) {
let response_text = trpl::get(url).await.text().await;
let title = Html::parse(&response_text)
.select_first("title")
.map(|title| title.inner_html());
(url, title)
}
page_title для двух URL-адресов, чтобы увидеть, какой вернётся первымМы начинаем с вызова page_title для каждого из URL-адресов, предоставленных пользователем. Мы сохраняем полученные фьючерсы как title_fut_1 и title_fut_2. Помните, они пока ничего не делают, потому что фьючерсы ленивы, и мы ещё не ожидали их. Затем мы передаём фьючерсы в trpl::select, который возвращает значение, указывающее, какой из переданных ему фьючерсов завершится первым.
Примечание: Под капотом trpl::select построен на более общей функции select, определённой в крейте futures. Функция select крейта futures может делать много вещей, которые не может делать функция trpl::select, но она также имеет дополнительную сложность, которую мы можем пока пропустить.
Любой фьючерс может законно «победить», поэтому не имеет смысла возвращать Result. Вместо этого trpl::select возвращает тип, который мы раньше не видели, — trpl::Either. Тип Either несколько похож на Result тем, что имеет два случая. Однако в отличие от Result в Either нет понятия успеха или неудачи. Вместо этого он использует Left и Right, чтобы указать «одно или другое»:
#![allow(unused)]
fn main() {
enum Either<A, B> {
Left(A),
Right(B),
}
}
Функция select возвращает Left с выходным значением этого фьючерса, если побеждает первый аргумент, и Right с выходным значением второго аргумента фьючерса, если побеждает он. Это соответствует порядку, в котором аргументы появляются при вызове функции: первый аргумент находится слева от второго.
Мы также обновили page_title, чтобы она возвращала тот же URL, который был передан. Таким образом, если страница, которая вернётся первой, не имеет <title>, который мы можем получить, мы всё равно можем напечатать осмысленное сообщение. С этой информацией мы завершаем, обновляя наш вывод println!, чтобы указать, какой URL завершился первым и какой, если он есть, <title> у веб-страницы по этому URL.
Вы создали небольшой работающий веб-скрапер! Выберите пару URL-адресов и запустите инструмент командной строки. Вы можете обнаружить, что некоторые сайты стабильно быстрее других, в то время как в других случаях более быстрый сайт меняется от запуска к запуску. Что более важно, вы изучили основы работы с фьючерсами, так что теперь мы можем углубиться в то, что мы можем делать с async.