Конкурентность и asyncio

Что происходит с выполнением других задач asyncio, когда корутина достигает await операции ввода-вывода?

Как GIL в CPython влияет на выполнение CPU-bound задач в нескольких потоках?

В сервисе две корутины запускаются через asyncio.gather, но внутри каждой вызывается обычная блокирующая функция. Какой эффект это окажет на выполнение задач?

import asyncio
import time

def blocking_work():
    time.sleep(2)

async def worker(name):
    print(f"{name}: start")
    blocking_work()
    print(f"{name}: done")

async def main():
    await asyncio.gather(worker("A"), worker("B"))

asyncio.run(main())

Задачу asyncio отменяют во время ожидания ввода-вывода. В какой момент и каким механизмом корутина узнаёт об отмене?

Сравните прямой await корутины и передачу её в asyncio.create_task: в чём главное различие их запуска?

Какой результат даст изменение обычной глобальной переменной в одном процессе для другого процесса Python?

За счёт какого механизма asyncio.to_thread не блокирует event loop при выполнении синхронной функции?

В двух корутинах asyncio обновляется общее состояние с фактической приостановкой между чтением и записью. Может ли возникнуть гонка данных в одном event loop?

Разберите ситуацию: синхронная функция уже запустила event loop, а затем пытается вызвать asyncio.run для корутины. Каков результат?

Вам нужно вынести вычисление из event loop в отдельный процесс. Какой механизм помешает этому коду передать функцию исполнителю?

import asyncio
from concurrent.futures import ProcessPoolExecutor

async def main():
    def square(x):
        return x * x

    loop = asyncio.get_running_loop()
    with ProcessPoolExecutor() as pool:
        result = await loop.run_in_executor(pool, square, 3)
        print(result)

if __name__ == "__main__":
    asyncio.run(main())

Практическая ситуация: в одном event loop первая корутина удерживает threading.Lock во время await, а вторая пытается захватить этот lock. Может ли event loop зависнуть?

Практическая ситуация: определите, когда завершится третий вызов put и почему, если потребитель начнёт работу через секунду.

import asyncio

async def producer(queue):
    for item in range(3):
        print("before", item)
        await queue.put(item)
        print("after", item)

async def main():
    queue = asyncio.Queue(maxsize=2)
    task = asyncio.create_task(producer(queue))
    await asyncio.sleep(1)
    print("got", await queue.get())
    await task

asyncio.run(main())

Что произойдёт с основным потоком Python, если рабочая функция обычного threading.Thread завершится необработанным исключением?

Объясните механизм: почему объект корутины сам по себе не начинает выполнение?

В сервисе нужно ограничить число корутин, одновременно обращающихся к внешнему API. Что именно делает asyncio.Semaphore с корутинами, превысившими лимит?

Сопоставьте планирование корутин asyncio и потоков: кто определяет момент передачи управления?

Какой механизм Python обеспечивает отдельное состояние для каждого потока без передачи этого состояния через аргументы функций?

Как безопасно передать работу из другого потока в уже работающий event loop asyncio?

При отмене asyncio-задачи, ожидающей результат функции в пуле потоков, прекращается ли уже выполняющаяся функция?

Как завершение основного потока влияет на обычный не-daemon поток Python?