Что такое асинхронность в python

Зачем нужна асинхронность

Бекенд-разработчики обычно пишут синхронный код. В нём команды исполняются одна за другой:

# . grand_total = sum(cart_products.values()) print(grand_total) # . 

Ничего не требуется предпринимать, если синхронный код работает быстро. Проблемы возникают, когда он подвисает и не реагирует на команды пользователя. Синхронный email-клиент не сможет реагировать на нажатие кнопок, пока он скачивает почту. А скачивание тоже происходит синхронно: пока не ответит первый email-провайдер, клиент не отправит запрос второму.

Асинхронное программирование позволяет сделать несколько быстрых действий, пока не завершится долгое. Email-клиент может показывать пользователю скачанные письма, пока новая почта асинхронно загружается. Вот как это выглядит в псевдокоде:

while True: download_progress = download_emails_step_by_step(download_progress) click = read_click() # . 

Асинхронным этот код делает функция, которая названа download_emails_step_by_step . Она скачивает не всю почту за раз, а понемногу. Скачав кусочек, она возвращает управление циклу while True . Этот цикл дальше запустит read_click , которая вернёт клик пользователя, если он был, и None , если не было. Другие функции в этом цикле аналогичные: они делают небольшое действие, останавливаются, возвращают управление циклу, который их снова запускает позже.

Обычные функции в Питоне работают не так, как это принято в асинхронном программировании. Функция input , например, ждёт пользовательского ввода и может долго не возвращать управление вызвавшему её коду. Поэтому в язык добавили библиотеку asyncio, которая содержит инструменты для работы с асинхронным кодом и асинхронные эквиваленты синхронных функций (например, sleep).

Привычные инструменты ломают асинхронный код

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

Асинхронный код подходит всегда, когда есть несколько потоков ввода, и достаточно обработать только часть данных, но быстро и одновременно у всех потоков. Для решения этого класса задач и нужен асинхронный Python.

Если потоков данных много, то спасет асинхронность

Попробуйте бесплатные уроки по Python

Получите крутое код-ревью от практикующих программистов с разбором ошибок и рекомендациями, на что обратить внимание — бесплатно.

Переходите на страницу учебных модулей «Девмана» и выбирайте тему.

Асинхронное программирование на asyncio

Ассинхроность дает нам плюс к многозадачности.Даваете посмотрим два примера кода:

1.2K показов
1.5K открытий

import time def start(): print(1) def time(): time.sleep(20) print(2) def end(): print(3) def main(): start_time = time.time() start() time() end() end_time = time.time() elapsed_time = end_time — start_time print(f»Elapsed time: seconds») if __name__ == «__main__»: main()

И с ассинхроностью:

import asyncio import time async def start(): print(1) async def time(): await asyncio.sleep(20) print(2) def end(): print(3) async def main(): start_time = time.time() await start() await time() end() end_time = time.time() elapsed_time = end_time — start_time print(f»Elapsed time: seconds») if __name__ == «__main__»: asyncio.run(main())

Здесь скорость двух примеров относительна близка,но в больших проектах лучше использовать ассинхроность.

Теперь переидем к обьяснению:

Асинхронность (асинхронное программирование) в программировании означает выполнение задач без явного ожидания завершения предыдущих задач. Вместо того, чтобы блокировать выполнение программы при ожидании завершения операции, асинхронный код позволяет программе продолжать работу и выполнять другие задачи во время ожидания.

import asyncio async def task1(): print(«Task 1 started») await asyncio.sleep(2) # Имитируем длительную операцию print(«Task 1 completed») async def task2(): print(«Task 2 started») await asyncio.sleep(1) # Имитируем длительную операцию print(«Task 2 completed») async def main(): print(«Main started») await asyncio.gather(task1(), task2()) # Запускаем задачи параллельно print(«Main completed») asyncio.run(main())

В этом примере мы используем модуль asyncio для создания асинхронной программы. Есть две асинхронные задачи task1() и task2(), которые имитируют длительные операции, используя await asyncio.sleep() для приостановки выполнения на определенное время.

Функция main() является точкой входа в программу и запускает задачи task1() и task2() параллельно с помощью asyncio.gather(). Важно отметить, что когда одна из задач ожидает (await), другая задача может продолжить выполнение, не блокируя программу.

Выполнение кода показывает, что «Task 1 started» и «Task 2 started» выводятся одновременно, а затем после задержки «Task 2 completed» выводится раньше, чем «Task 1 completed». Это демонстрирует параллельное выполнение асинхронных задач.

Асинхронность позволяет эффективно использовать ресурсы и повышает отзывчивость программы, особенно когда есть операции ввода-вывода (I/O), такие как чтение из сети или запись на диск. Вместо блокировки выполнения при ожидании I/O операций, асинхронный код может переключаться между задачами, позволяя другим задачам продолжать выполнение.

Обратите внимание, что для запуска асинхронной программы мы используем asyncio.run(main()), которая создает цикл событий asyncio и запускает функцию main() в этом цикле событий.

Спасибо за просмотр статьй.

Асинхронное программирование на Python

Отличия между асинхронным и синхронным кодом

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

Асинхронное программирование позволяет запускать операции параллельно, не дожидаясь выполнения последовательности. Это как если бы у вас было восемь рук и вы могли одновременно мыть посуду, пылесосить, читать газету и гладить кота. Жаль, что это невозможно в быту — зато вполне реально в разработке ПО. К тому же асинхронное программирование на Python становится все более популярным.

Где асинхронность применяется в реальном мире

Темы асинхронного программирования часто стараются избегать, особенно на начальных этапах изучения языка. Ее считают сложной и относят к разряду «для посвященных или одаренных» разработчиков. На самом деле «асинхронные дела» окружают нас буквально на каждом шагу.

Основы Python
Курс для IT-специалистов

Например, вы провожаете родственников и просите их позвонить, как только они доберутся до дома. А дальше спокойно занимаетесь своими делами и не названиваете им каждую минуту с проверкой: «Уже доехали?» Потому что звонок от родственников поступит сам, как только они доберутся до дома.

То есть функция «Звонок от родственников» ожидает события «Родственники приехали домой». И как только это событие произойдет, функция сразу сработает.

Или вы ставите напоминание в календаре на конкретную дату и время: «Созвон с коллегами». А потом напрочь забываете об этом событии. Но календарь не забудет!

Он обязательно напомнит об этом в указанное время. И ему плевать, что в этот момент вы можете мыться или стоять в трехчасовой пробке. Задача «Созвон с коллегами» находится в режиме ожидания. Она никак не мешает выполнению основной программы «Повседневная жизнь». Но как только наступит заранее заданное условие — дата и время, — эта функция активируется и вмешается в привычный ход жизни.

Особенности асинхронного программирования на Python

С чего начать изучение Python, как поймать Python-дзен и для чего этот язык пригодится в повседневной жизни, рассказываем на бесплатном вебинаре «Зачем специалисту Python?».

Обычные функции

Давайте запрограммируем такую ситуацию с уведомлением. Повседневную жизнь представим с помощью функции main ( ) . А уведомление — с помощью функции notification ( ) .

Внутри функции notification ( ) находится задержка в 10 секунд, чтобы имитировать отложенное задание. Если запустить код, то мы увидим, что поговорить с коллегой и поесть не удастся, потому что программа застынет на выполнении notification ( ) и будет ждать 10 секунд, пока уведомление не придет и не спасет от голодной смерти ��

Очевидно, что есть и разговаривать с коллегой мы хотим в то время, пока идет обратный отсчет до уведомления. То есть важно сделать так, чтобы работа функции notification ( ) не прерывала работу функции main ( ) .

Корутины

Чтобы решить этот вопрос, необходимо функцию notification ( ) сделать асинхронной, то есть работающей независимо от всего остального. Для этого в начале приписываем магическое async.

Теперь, если запустим программу, она выполнится мгновенно! Мы и поедим, и с коллегой пообщаемся, вот только помимо этого получим странное предупреждение.

Что же произошло? async — это оператор Python, обертка над основной функцией. Теперь, когда вы вызовете функцию notification ( ) , она вернет специальный объект — корутину (coroutine).

• Корутина тоже представляет собой функцию, которую нужно вызвать отдельно. Об этом и сообщает Python.

Обычный вызов notification ( ) теперь не исполняет функцию, а превращает ее в корутину, которую нужно вызвать. Чтобы это сделать, используем оператор await .

Теперь запуск кода приведет к новой проблеме:

Python будет выполнять await только в том случае, если он будет вызван внутри асинхронной функции. То есть функцию main ( ) необходимо тоже сделать асинхронной.

Но тогда мы получили еще одну корутину, которую также кто-то должен вызвать и сделать это опять только внутри асинхронной функции! Что же делать? Замкнутый круг ��

Asyncio спешит на помощь

Для управления асинхронными функциями в Python используется специальный модуль asyncio. Его поддержка впервые появилась в версии Python 3.5 в 2015 году. Добавим его к программе и запустим корутину main ( ) , используя метод run( ).

В терминах асинхронного программирования функция main ( ) будет называться циклом обработки событий (event loop). Это основной цикл программы, который вызывает все асинхронные функции, необходимые для работы.

Теперь программа вновь заработает! Правда, уведомление о созвоне снова не даст поесть и пообщаться с коллегой… Все опять работает как обычная последовательность действий.

Дело в том, что недостаточно просто запустить корутину — необходимо создать задачу (task), которая это сделает.

Ура! Наконец можно спокойно пообедать, поговорить с коллегой и заняться любыми другими делами. А уведомление о встрече придет тогда, когда истечет таймер, — в нашем случае это 10 секунд.

Запустите программу и обратите внимание на последовательность работы функции print( ). Несмотря на то что «Едим» и «Разговариваем с коллегой» выполняются после вызова корутины notification ( ) , мы увидим их первыми, потому что корутина выполняется асинхронно относительно основного цикла обработки событий main ( ) .

Знатоки Python могут закидать меня помидорами за такой пример, так как на самом деле time.sleep( ) нельзя использовать при создании нескольких асинхронных событий внутри event loop. А также не хватает вызова корутины через await . Но не торопитесь: обо всем по порядку.

Когда работы много

Зачем специалисту Python?
Бесплатный вебинар

Рассмотрим еще пример. Представим, что у нас есть погодная станция, которая опрашивает датчики и отображает полученную информацию на экране. Время опроса датчиков может быть разным.

Создадим основную функцию, внутри которой будем вызывать функции, возвращающие данные для погодной станции. Чтобы имитировать задержки, воспользуемся функцией time.sleep( ). Также будем измерять общее время
работы программы с помощью time.time( ).

Традиционное решение — вызов функций друг за другом. Так как выполнение main ( ) приостанавливается в момент вызова get_temp ( ) и get_pres ( ) , несложно подсчитать, что общее время работы будет равно сумме времени, затраченного на выполнение всех функций, вызываемых внутри main ( ) .

Еще бы! Ведь сейчас эти функции выполняются последовательно друг за другом — измерение давления не начнется, пока не закончится измерение температуры. Но зачем ждать, если одно вообще не зависит от другого? Перепишем код, сделав функции запроса асинхронными.

Теперь, если запустим программу, увидим странную особенность: функции измерения работают последовательно — асинхронностью здесь и не пахнет. Программа выполняется все так же долго — 6 секунд. А терминал вообще вывел информацию в странном порядке.

Почему так происходит? Все дело в задержках, которые мы создали. Асинхронно сейчас выполняется только main ( ) (цикл событий) относительно функций, которые он вызывает. Это видно по моментальному выводу о начале и конце измерения еще до того, как мы получили непосредственно сами данные.

А вот функции get_temp ( ) и get_pres ( ) выполняются последовательно, потому что внутри содержат обычную функцию time.sleep( ), тормозящую всю работу. Чтобы исправить этот эффект, необходимы корутины, которые будут создавать задержку и при этом не будут тормозить вызов других функций. Исправьте time.sleep( ) на asyncio.sleep( ) и не забудьте про await , ведь теперь мы работаем с корутинами.

Если запустим программу, то убедимся в том, что функции действительно стали работать асинхронно. Вывод происходит моментально, идет запрос информации и… на этом программа завершается, показывая время работы 0 секунд.

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

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

И время выполнения программы сократилось до 4 секунд вместо 6:

Теперь в цикл событий main ( ) можно добавить сколько угодно задач через asyncio. А общее время его работы всегда будет определяться временем работы самой долгой функции. Добро пожаловать в асинхронный мир!

Особенности асинхронности в Python

Привет, Хабр! Меня зовут Николай Нагорный, я работаю в Росбанке над платформой Advisors’ Axiom. В этом посте я подробно расскажу о важной фиче, которая появилась в Python 3.5 — асинхронности. Затрону основные концепции и инструменты, приведу примеры кода. Пост будет полезен новичкам для понимания основ асинхронности и, может, даже опытным разработчикам в поиске новых идей и подходов.

Начнем с определения. Асинхронность — это парадигма программирования, которая позволяет выполнять несколько задач одновременно, не дожидаясь завершения каждой из них; важный инструмент для решения проблем с производительностью в веб-приложениях и серверных технологиях. С момента появления асинхронности в Python сразу было доступно несколько способов реализации асинхронного кода. Чаще всего для асинхронных операций в Python используют библиотеки async/await и asyncio. Также асинхронность может быть использована для веб-приложений в сочетании с фреймворками, например с Django, Flask или Fast API.

Асинхронность в чистом Python

Один из способов реализации асинхронности в Python — декоратор @asyncio.coroutine. Вот функция-корутина, которая выполняет ожидание в течение некоторого времени:

import asyncio # импорт библиотеки @asyncio.coroutine # декоратор def my_coroutine(seconds): print ('Starting coroutine') yield from asyncio.sleep(seconds) # возвращаем результат print ('Finishing coroutine') loop = asyncio.get_event_loop () # создаем объект loop.run_until_complete(my_coroutine (2)) # запускаем loop.close () # закрываем

Другой, более предпочтительный способ появился в языке позднее — это асинхронные функции (Async Functions), которые вызываются через async. В примере ниже функция my_coroutine задана асинхронно, то есть программа не будет ждать завершения ее работы, а продолжит выполнение следующих команд:

import asyncio # импортируем библиотеку async def my_async_function (seconds) : # создаем асинхронную функцию print ('Starting async function') await asyncio.sleep (seconds) # вызываем метод await для ожидания print ('Finishing async function') loop = asyncio.get_event_loop () # создаем объект loop.run_until_complete(my_async_function (2)) # запускаем loop.close () # закрываем

Кроме того, в Python можно создавать асинхронные контексты с помощью ключевого слова async with. Это позволяет выполнять асинхронные операции внутри контекста, например открытие и закрытие файла:

import asyncio # импортируем библиотеку async def read_file (filename): # создаем асинхронную функцию async with open(filename, 'r') as f: # открываем файл на чтение contents = await f. read () # читаем весь файл print (contents)

Модуль asyncio с методами async functions, async with, контексты и корутины — выбор средств асинхронности в Python неплохой. Комбинируя их, можно создавать программы с высокой параллельностью и улучшать их производительность, а также избегать блокировок программы во время длительных операций. Помните, что асинхронный код сам по себе более сложен для понимания и реализации, поэтому используйте его с умом. И тогда перечисленные инструменты раскроют весь свой немаленький потенциал.

Асинхронность во фреймворках Python — Django, FastAPI, Flask

Теперь поговорим об использовании асинхронности с популярными фреймворками — Django, Flask и FastAPI. Ни один из них не имеет встроенной поддержки асинхронности, но ее можно добавить с помощью внешних библиотек.

Для реализации асинхронных вызовов FastAPI использует стандартный модуль asyncio и поддерживает асинхронные функции нативно, на уровне ядра. У Django и Flask такой поддержки нет, но они тоже умеют работать с асинхронными библиотеками asyncio или aiohttp. Так что разогнать свои веб-приложения с помощью асинхронности использование этих фреймворков не помешает. Вот пример реализации с библиотекой aiohttp в Flask:

import aiohttp # импортируем библиотеку для работы с асинхронным примером from flask import Flask # импортируем библиотеку для работы с фреймворком app = Flask(__name__) # создаем приложение @app.route("/") # объявляем страницу async def main(): # создаем асинхронную функцию async with aiohttp.ClientSession() as session: # открываем асинхронную клиентскую сессию async with session.get ("https://www.example.com") as response: # используя сессию делаем асинхронный запрос return response.text if __name__ == Il “__main__”: # объявляем секцию main app.run() # запускаем фреймворк по с настройками по умолчанию

Асинхронность в веб-приложениях лучше всего раскрывается при работе с длительными операциями или вызовами API. Но учтите, что так вы подписываетесь на более сложную отладку и поддержку.

Вот еще пример асинхронных функций в FastAPI: функция main использует asyncio.sleep для задержки выполнения на 10 секунд. Это может пригодиться, например, для ожидания ответа от внешнего API:

from fastapi import FastAPI # импортируем библиотеку для работы с фреймворком Aimport asyncio # импортируем библиотеку для работы с асинхронным примером app = FastAPI() # создаем приложение @app.get("/") # объявляем страницу async def main(): #создаем асинхронную функцию await asyncio.sleep(10) # с помощью асинхронной библиотеки запускаем наш пример return if __name__ == "__main__": # объявляем секцию main uvicorn.run (app) # запускаем фреймворк по с настройками по умолчанию

Что касается Django, то он также поддерживает асинхронное программирование с помощью внешних библиотек Django Channels.

from channels.generic.websocket import AsyncWebsocketConsumer #библиотека для работы с асинхронностью §class MyConsumer (AsyncWebsocketConsumer): async def connect(self): # создаем асинхронный метод await self.accept() # ожидаем await asyncio.sleep (10) # выполняем действия await self.send(text_data="Hello World") # отправляем данные await self.close() # закрываем

В этом примере класс MyConsumer реализует асинхронное вебсокет-соединение через метод connect. Метод accept принимает соединение, а метод send отправляет сообщение клиенту. Для задержки отправки сообщения на 10 секунд используется функция asyncio.sleep. И в конце метод close закрывает соединение.

С помощью асинхронного программирования вы можете использовать все доступные ресурсы для обработки множества запросов одновременно, а не ставить их в очередь. Создаются асинхронные вьюхи в каждом фреймворке по-своему. В Django вы можете использовать декоратор async из библиотеки asyncio. Для Flask — декоратор asyncio.coroutine; Flask использует библиотеку gevent для управления асинхронными задачами. FastAPI имеет встроенную поддержку асинхронных функций, поэтому там можно использовать async def. Выбирайте фреймворк для работы с асинхронностью исходя из собственных задач и предпочтений. Я привел варианты выше, поскольку они точно предлагают удобный инструментарий для управления асинхронными задачами.

ORM — Object-Relational Mapping

ORM (Object-Relational Mapping) — это технология, которая позволяет связаться с базой данных, используя объекты Python, вместо того чтобы писать сырые SQL-запросы. Многие ORM для Python, такие как SQLAlchemy и Django ORM, поддерживают асинхронные версии. Библиотеки asyncio или asyncpg позволяют использовать асинхронные версии этих ORM в асинхронных приложениях.

С помощью ORM вы можете выполнять запросы к базе данных асинхронно, вместо того чтобы ждать ответа перед выполнением следующей задачи. Так вы можете увеличить производительность приложения и оптимизировать использование ресурсов. Пример асинхронного подключения к СУБД:

import asyncio # библиотека для работы с асинхронным кодом import asyncpg # библиотека для подключения к субд async def main(): ## создаем асинхронную функцию conn = await asyncpg.connect (user='user', password='password', database='database', host='host') # подключаем к субд # создание таблицы await conn.execute(''' CREATE TABLE IF NOT EXISTS test_table ( id serial PRIMARY KEY, name text NOT NULL ) ''') # вставка данных в таблицу await conn.execute('" INSERT INTO test_table (name) VALUES ($1) ''', 'John Doe') # выборка данных из таблицы result = await conn.fetch(''' SELECT * FROM test_table ''') print (result) # показываем результат await conn.close() # закрываем соединение asyncio.run(main())

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

В нашей троице Django, Flask и FastAPI асинхронность в работе с базой данных можно реализовать через библиотеки asyncio и aiomysql. Они представляют собой асинхронные версии стандартных модулей для работы с базами данных, psycopg2 и mysql-python. Например в Django можно использовать asyncpg для работы PostgreSQL в асинхронном режиме. Соответственно, в Flask и FastAPI можно использовать aiomysql для MySQL.

Асинхронные ORM, такие как asyncio-orm или Tortoise-ORM, могут улучшить и производительность работы с базой данных в асинхронном режиме. В большинстве случаев асинхронный код позволяет использовать базу данных более эффективно за счет минимизации ожидания выполнения запросов. Покажу, как асинхронность может улучшить работу с базой данных, на примере с asyncio и aiomysql:

pip install aiomysql import asyncio # библиотека для работы с асинхронным кодом import aiomysql # библиотека для подключения к субд async def main(): # создаем асинхронную функцию conn = await aiomysql.connect(host='localhost', user='user', password='password', db='dbname', charset='utf8mb4') # подключаем к субд async with conn.cursor() as cursor: # открываем подключение await cursor.execute ("SELECT * FROM table") # добавляем запрос result = await cursor.fetchall() # получаем все из таблицы print(result) # показываем запрос asyncio.run(main ())

Здесь мы создали простое приложение, которое подключается к базе данных и выполняет запрос. Используется асинхронный контекст-менеджер для управления соединением с базой данных, а затем выполняется SELECT-запрос и вывод результата.

Использование асинхронности в ORM может повысить производительность приложения, поскольку запросы к базе данных при этом выполняются в фоновом режиме, без блокировки потоков исполнения. Но помните о неминуемом усложнении кода и отладки. Django ORM и некоторые другие ORM поддерживают асинхронные запросы. Запросы эти не встроены в фундаментальный дизайн фреймворка и могут требовать дополнительных инструментов и настроек. С этой точки зрения проще использовать Flask с его asyncio.

Ограничения асинхронности

Не все базы данных поддерживают асинхронный режим работы — например реляционные базы данных, такие как PostgreSQL и MySQL. При использовании таких баз данных с асинхронным кодом вам могут потребоваться специальные библиотеки типа asyncpg.

Еще одно ограничение возникает при работе с транзакциями. Они обычно выполняются в блокирующем режиме, который заставляет все остальные запросы ждать, пока транзакция не будет завершена. Это может стать проблемой в асинхронных приложениях, так как они ожидают ответа в неблокирующем режиме. Здесь есть несколько решений: использование асинхронных ORM (asyncpg) или использование блокировок на уровне базы данных. Однако так вы будете вынуждены потерять в производительности и писать более сложный код.

Все три фреймворка, что мы рассматривали выше — FastAPI, Django и Flask — используют ORM (Object Relational Mapping) для управления базами данных. В ORM для работы с базами данных предусмотрены простые CRUD-операции (Create, Read, Update, Delete). В FastAPI и Flask ORM реализуют через сторонние библиотеки, такие как SQLAlchemy и Flask-SQLAlchemy. После этого с базами данных можно использовать и синхронные, и асинхронные операции (async for, async with, async/await). Django же с версии 3.0 поддерживает асинхронные операции с базой данных нативно, и вам тоже не придется ждать.

Заключение

Сегодня асинхронность очень важна для решения проблем с производительностью в веб-приложениях. В Python асинхронные функции можно организовать с помощью модуля asyncio. В фреймворках Django, Flask и FastAPI можно использовать асинхронные возможности для оптимизации работы с базами данных и выполнения сложных операций.

Следует помнить, что асинхронный стиль программирования усложнит код и отладку. И, конечно, потребует довольно глубокого понимания асинхронных принципов. Так что решение об использовании асинхронности должно быть осознанным и основываться на конкретных задачах.

Несмотря на это, асинхронность остается важным инструментом для улучшения производительности веб-приложений.