Программирование Python

Допустим, поток должен передать данные в asyncio.Queue, обслуживаемую другим потоком с event loop. Можно ли безопасно вызвать queue.put из исходного потока?

Делает ли multiprocessing.shared_memory.SharedMemory запись в общий буфер атомарной между процессами?

Вам дан код с ограничением времени ожидания. Как asyncio.wait обработает задачу, не завершившуюся к моменту тайм-аута?

import asyncio

async def job():
    await asyncio.sleep(5)
    return 42

async def main():
    task = asyncio.create_task(job())
    done, pending = await asyncio.wait({task}, timeout=0.1)
    print(task in done, task in pending, task.cancelled())

asyncio.run(main())

Два процесса подключены к одному объекту multiprocessing.shared_memory.SharedMemory. Почему запись одного процесса становится видна другому?

Сервис запускает фоновую задачу через asyncio.create_task, после чего основная корутина завершается. Что произойдёт с фоновой задачей?

В чём принципиальное отличие threading.Lock от threading.RLock в вопросе владения блокировкой?

Практическая ситуация: рабочая функция в ThreadPoolExecutor завершилась исключением, но Future никто не вызывает через result. Где сохраняется ошибка и когда она станет видна?

Сохраняет ли asyncio.Lock порядок ожидания корутин при освобождении блокировки?

Объясните механизм сохранения локального состояния корутины asyncio между двумя await.

Сервису нужно отдавать результаты завершившихся корутин сразу, не дожидаясь самой медленной. Какой механизм asyncio выбрать?

Гарантирует ли asyncio строгую очередность выполнения корутин, готовых к продолжению?

В дочернем процессе, созданном через fork, почему изменение одного элемента большой структуры может резко увеличить потребление памяти?

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

Сервису требуется передать результат от одной корутины другой без блокировки event loop. Как asyncio.Future обеспечивает такую передачу?

Изменение списка получателем после передачи через multiprocessing.Queue: увидит ли эти изменения отправитель?

При запуске с методом spawn этот модуль создаёт дочерний процесс рекурсивно. Какую роль играет проверка __name__ == "__main__"?

import asyncio
import multiprocessing as mp

ctx = mp.get_context("spawn")

def worker():
    asyncio.run(asyncio.sleep(0))

async def main():
    process = ctx.Process(target=worker)
    process.start()
    process.join()

asyncio.run(main())

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

import asyncio

async def job(name, delay, fail=False):
    await asyncio.sleep(delay)
    if fail:
        raise ValueError(name)
    print(name)
    return name

async def main():
    tasks = [
        asyncio.create_task(job("A", 0.1, True)),
        asyncio.create_task(job("B", 0.2)),
    ]
    try:
        await asyncio.gather(*tasks)
    except ValueError:
        print("gather failed")
    await asyncio.sleep(0.2)
    print(tasks[1].done())

asyncio.run(main())

При истечении тайм-аута asyncio.wait_for что происходит с ожидаемой корутиной?

Можно ли напрямую создать asyncio-задачу из другого потока, если event loop уже запущен?

При каких условиях два потока CPython могут реально выполнять работу параллельно, несмотря на GIL?