Основы асинхронного программирования: async, await, фьючерсы и стримы
Многие операции, которые мы просим компьютер выполнить, могут занять некоторое время. Было бы неплохо, если бы мы могли делать что-то ещё, пока ждём завершения этих длительных процессов. Современные компьютеры предлагают две техники для работы более чем с одной операцией одновременно: параллелизм и конкурентность. Однако логика наших программ написана в основном линейным образом. Мы хотели бы иметь возможность указать операции, которые программа должна выполнить, и точки, в которых функция может приостановиться, а какая-то другая часть программы могла бы выполняться вместо неё, без необходимости заранее точно указывать порядок и способ выполнения каждого фрагмента кода. Асинхронное программирование — это абстракция, которая позволяет нам выражать наш код в терминах потенциальных точек приостановки и итоговых результатов, беря на себя детали координации за нас.
Эта глава строится на использовании потоков в главе 16 для параллелизма и конкурентности, вводя альтернативный подход к написанию кода: фьючерсы, стримы в Rust и синтаксис async и await, которые позволяют нам выражать, как операции могут быть асинхронными, а также сторонние крейты, реализующие асинхронные рантаймы: код, который управляет и координирует выполнение асинхронных операций.
Рассмотрим пример. Допустим, вы экспортируете видео, которое вы создали на семейном празднике, — операция, которая может занять от нескольких минут до нескольких часов. Экспорт видео будет использовать столько мощности CPU и GPU, сколько сможет. Если бы у вас был только один ядер CPU, и ваша операционная система не приостанавливала бы этот экспорт до его завершения — то есть если бы она выполняла экспорт синхронно, — вы не могли бы делать ничего другого на вашем компьютере, пока эта задача выполняется. Это был бы довольно разочаровывающий опыт. К счастью, операционная система вашего компьютера может и делает это — она невидимо прерывает экспорт достаточно часто, чтобы вы могли одновременно выполнять другую работу.
Теперь допустим, вы скачиваете видео, которым поделился кто-то другой, что также может занять некоторое время, но не занимает столько времени CPU. В этом случае CPU должен ждать поступления данных из сети. Хотя вы можете начать читать данные, как только они начнут поступать, может потребоваться некоторое время, чтобы все они появились. Даже когда все данные присутствуют, если видео довольно большое, может потребоваться по крайней мере секунда или две, чтобы загрузить его полностью. Это может звучать не так уж много, но это очень долгое время для современного процессора, который может выполнять миллиарды операций каждую секунду. Опять же, ваша операционная система невидимо прервёт вашу программу, чтобы позволить CPU выполнять другую работу, пока ожидается завершение сетевого вызова.
Экспорт видео — это пример операции, ограниченной CPU или ограниченной вычислениями. Она ограничена потенциальной скоростью обработки данных компьютером в CPU или GPU и тем, сколько этой скорости он может выделить для операции. Скачивание видео — это пример операции, ограниченной вводом-выводом, потому что она ограничена скоростью ввода и вывода компьютера; она может идти только так быстро, как данные могут быть переданы по сети.
В обоих этих примерах невидимые прерывания операционной системы обеспечивают форму конкурентности. Однако эта конкурентность происходит только на уровне всей программы: операционная система прерывает одну программу, чтобы другие программы могли выполнять работу. Во многих случаях, поскольку мы понимаем наши программы на гораздо более детальном уровне, чем операционная система, мы можем заметить возможности для конкурентности, которые операционная система не видит.
Например, если мы создаём инструмент для управления загрузкой файлов, мы должны быть в состоянии написать нашу программу так, чтобы запуск одной загрузки не блокировал пользовательский интерфейс, и пользователи могли запускать несколько загрузок одновременно. Однако многие API операционной системы для взаимодействия с сетью являются блокирующими; то есть они блокируют продвижение программы до тех пор, пока обрабатываемые ими данные не будут полностью готовы.
Примечание: Именно так работает большинство вызовов функций, если подумать. Однако термин блокирующий обычно зарезервирован для вызовов функций, которые взаимодействуют с файлами, сетью или другими ресурсами на компьютере, потому что именно в этих случаях отдельная программа выиграла бы от того, чтобы операция была не-блокирующей.
Мы могли бы избежать блокировки нашего основного потока, запустив выделенный поток для загрузки каждого файла. Однако накладные расходы системных ресурсов, используемых этими потоками, в конечном итоге станут проблемой. Было бы предпочтительнее, если бы вызов изначально не блокировал, а вместо этого мы могли бы определить ряд задач, которые мы хотели бы, чтобы наша программа выполнила, и позволить рантайму выбрать лучший порядок и способ их выполнения.
Именно это даёт нам абстракция async (сокращение от asynchronous) в Rust. В этой главе вы узнаете всё об async, пока мы рассматриваем следующие темы:
- Как использовать синтаксис
asyncиawaitв Rust и выполнять асинхронные функции с помощью рантайма - Как использовать модель async для решения некоторых из тех же задач, которые мы рассматривали в главе 16
- Как многопоточность и async предоставляют взаимодополняющие решения, которые вы можете комбинировать во многих случаях
Однако прежде чем мы увидим, как async работает на практике, нам нужно сделать небольшое отступление, чтобы обсудить различия между параллелизмом и конкурентностью.
Параллелизм и конкурентность
До сих пор мы относились к параллелизму и конкурентности как в основном к взаимозаменяемым понятиям. Теперь нам нужно более точно различать их, потому что различия проявятся, когда мы начнём работать.
Рассмотрим различные способы, которыми команда могла бы разделить работу над программным проектом. Вы могли бы назначить одному члену несколько задач, назначить каждому члену одну задачу или использовать смесь этих двух подходов.
Когда отдельный человек работает над несколькими различными задачами до того, как какая-либо из них завершена, это конкурентность. Один из способов реализовать конкурентность похож на то, как если бы у вас было два разных проекта, извлечённых на ваш компьютер, и когда вам становится скучно или вы застреваете на одном проекте, вы переключаетесь на другой. Вы всего один человек, поэтому вы не можете продвигаться по обеим задачам в одно и то же время, но вы можете выполнять многозадачность, продвигаясь по одной за раз, переключаясь между ними (см. рисунок 17-1).
Когда команда разделяет группу задач, позволяя каждому члену взять одну задачу и работать над ней самостоятельно, это параллелизм. Каждый человек в команде может продвигаться в одно и то же время (см. рисунок 17-2).
В обоих этих рабочих процессах вам может потребоваться координация между различными задачами. Возможно, вы думали, что задача, назначенная одному человеку, полностью независима от работы всех остальных, но на самом деле для её выполнения сначала требуется, чтобы другой человек в команде завершил свою задачу. Некоторую часть работы можно было бы выполнить параллельно, но некоторая часть на самом деле была последовательной: она могла происходить только последовательно, одна задача за другой, как на рисунке 17-3.
Аналогично, вы можете понять, что одна из ваших собственных задач зависит от другой вашей задачи. Теперь ваша конкурентная работа также стала последовательной.
Параллелизм и конкурентность могут также пересекаться друг с другом. Если вы узнаёте, что коллега застрял, пока вы не завершите одну из ваших задач, вы, вероятно, сосредоточите все свои усилия на этой задаче, чтобы «разблокировать» вашего коллегу. Вы и ваш коллега больше не можете работать параллельно, и вы также больше не можете работать конкурентно над своими собственными задачами.
Та же базовая динамика действует в программном обеспечении и аппаратном обеспечении. На машине с одним ядром CPU процессор может выполнять только одну операцию за раз, но он всё ещё может работать конкурентно. Используя такие инструменты, как потоки, процессы и async, компьютер может приостанавливать одну активность и переключаться на другие, прежде чем в конечном итоге вернуться к этой первой активности. На машине с несколькими ядрами CPU он также может выполнять работу параллельно. Одно ядро может выполнять одну задачу, в то время как другое ядро выполняет совершенно не связанную с ней задачу, и эти операции на самом деле происходят одновременно.
Выполнение асинхронного кода в Rust обычно происходит конкурентно. В зависимости от аппаратного обеспечения, операционной системы и используемого нами асинхронного рантайма (подробнее об асинхронных рантаймах вскоре) эта конкурентность может также использовать параллелизм под капотом.
Теперь давайте погрузимся в то, как асинхронное программирование в Rust на самом деле работает.