Собираем всё вместе: фьючерсы, задачи и потоки
Как мы видели в главе 16, потоки предоставляют один подход к конкурентности. В этой главе мы увидели другой подход: использование async с фьючерсами и стримами. Если вы задаётесь вопросом, когда выбрать один метод вместо другого, ответ таков: зависит! И во многих случаях выбор не между потоками или async, а скорее потоками и async.
Многие операционные системы предоставляли модели конкурентности на основе потоков на протяжении десятилетий, и многие языки программирования поддерживают их в результате. Однако эти модели не лишены компромиссов. Во многих операционных системах они используют довольно много памяти для каждого потока. Потоки также являются вариантом только тогда, когда ваша операционная система и аппаратное обеспечение их поддерживают. В отличие от распространённых настольных и мобильных компьютеров, некоторые встраиваемые системы вообще не имеют ОС, поэтому они также не имеют потоков.
Модель async предоставляет другой — и в конечном счёте дополняющий — набор
компромиссов. В модели async конкурентные операции не требуют собственных
потоков. Вместо этого они могут выполняться в задачах, как когда мы использовали trpl::spawn_task, чтобы
запустить работу из синхронной функции в разделе о стримах. Задача похожа на поток, но вместо того, чтобы управляться
операционной системой, она управляется кодом уровня библиотеки: средой выполнения.
Есть причина, по которой API для порождения потоков и порождения задач настолько похожи. Потоки действуют как граница для наборов синхронных операций; конкурентность возможна между потоками. Задачи действуют как граница для наборов асинхронных операций; конкурентность возможна как между, так и внутри задач, потому что задача может переключаться между фьючерсами в своём теле. Наконец, фьючерсы являются самой гранулярной единицей конкурентности в Rust, и каждый фьючерс может представлять дерево других фьючерсов. Среда выполнения — в частности, её исполнитель — управляет задачами, а задачи управляют фьючерсами. В этом смысле задачи похожи на лёгкие, управляемые средой выполнения потоки с дополнительными возможностями, которые появляются благодаря управлению средой выполнения, а не операционной системой.
Это не означает, что асинхронные задачи всегда лучше потоков (или наоборот).
Конкурентность с потоками в некотором смысле является более простой моделью программирования,
чем конкурентность с async. Это может быть как сильной, так и слабой стороной. Потоки в некотором смысле
«выстрелил и забыл»; у них нет нативного эквивалента фьючерса, поэтому они
просто выполняются до завершения, не прерываясь, кроме как самой операционной
системой.
И оказывается, что потоки и задачи часто работают
очень хорошо вместе, потому что задачи могут (по крайней мере, в некоторых средах выполнения) перемещаться
между потоками. Фактически, под капотом среда выполнения, которую мы
использовали — включая функции spawn_blocking и spawn_task — по умолчанию многопоточна! Многие среды выполнения используют подход, называемый перехватом работы (work stealing), чтобы
прозрачно перемещать задачи между потоками на основе того, как потоки
в настоящее время используются, чтобы улучшить общую производительность системы. Этот
подход фактически требует и потоков, и задач, и, следовательно, фьючерсов.
Размышляя о том, какой метод использовать когда, рассмотрите эти практические правила:
- Если работа очень параллелизуема (то есть привязана к CPU), например обработка кучи данных, где каждая часть может обрабатываться отдельно, потоки — лучший выбор.
- Если работа очень конкурентна (то есть привязана к вводу-выводу), например обработка сообщений из кучи разных источников, которые могут приходить через разные интервалы или с разной скоростью, async — лучший выбор.
И если вам нужны и параллелизм, и конкурентность, вам не нужно выбирать между потоками и async. Вы можете свободно использовать их вместе, позволяя каждому играть свою роль, в которой он лучше всего. Например, листинг 17-25 показывает довольно распространённый пример такого сочетания в реальном коде на Rust.
extern crate trpl; // for mdbook test
use std::{thread, time::Duration};
fn main() {
let (tx, mut rx) = trpl::channel();
thread::spawn(move || {
for i in 1..11 {
tx.send(i).unwrap();
thread::sleep(Duration::from_secs(1));
}
});
trpl::block_on(async {
while let Some(message) = rx.recv().await {
println!("{message}");
}
});
}
Мы начинаем с создания асинхронного канала, затем порождаем поток, который забирает
владение отправляющей стороной канала с помощью ключевого слова move. Внутри
потока мы отправляем числа от 1 до 10, засыпая на секунду между
каждым. Наконец, мы запускаем фьючерс, созданный асинхронным блоком, переданным в
trpl::block_on, точно так же, как мы делали на протяжении всей главы. В этом фьючерсе мы
ожидаем эти сообщения, как и в других примерах передачи сообщений, которые мы
видели.
Возвращаясь к сценарию, с которого мы открыли главу, представьте запуск набора задач кодирования видео с использованием выделенного потока (поскольку кодирование видео привязано к вычислениям), но уведомление пользовательского интерфейса о том, что эти операции завершены, через асинхронный канал. Существует бесчисленное множество примеров таких комбинаций в реальных случаях использования.
Итоги
Это не последний раз, когда вы увидите конкурентность в этой книге. Проект в главе 21 применит эти концепции в более реалистичной ситуации, чем более простые примеры, обсуждаемые здесь, и напрямую сравнит решение задач с использованием потоков против задач и фьючерсов.
Какой бы из этих подходов вы ни выбрали, Rust даёт вам инструменты, необходимые для написания безопасного, быстрого, конкурентного кода — будь то для высокопроизводительного веб-сервера или встраиваемой операционной системы.
Далее мы поговорим об идиоматичных способах моделирования задач и структурирования решений по мере роста ваших программ на Rust. Кроме того, мы обсудим, как идиомы Rust соотносятся с теми, которые вы могли знать из объектно-ориентированного программирования.