Как в Python решить 10 CPU-bound и 10 IO-bound задач?

Пример решения 10 CPU-bound и 10 IO-bound задач на Python

• CPU-bound-задачи: вычислительная нагрузка приходится на CPU, поэтому требуется распределение работы по ядрам
• IO-bound-задачи: выполнение замедляется из-за ожидания операций ввода-вывода

Вариант решения:

1. CPU-bound-задачи: - Применить multiprocessing.Pool, чтобы распределить работу между несколькими процессами - В каждом процессе выполнять функцию с высокой вычислительной нагрузкой - Не зависеть от ограничений потоков, связанных с GIL (Global Interpreter Lock) - Пример кода:

from multiprocessing import Pool

def cpu_task(x):
# CPU-интенсивная операция
return x * x

if __name__ == '__main__':
with Pool(10) as p:
results = p.map(cpu_task, range(10))
print(results)

1. IO-bound-задачи: - Задействовать asyncio и асинхронные библиотеки, например aiohttp для HTTP - Обрабатывать ожидание IO эффективно, не блокируя выполнение - Пример кода:

import asyncio
import aiohttp

async def io_task(url):
async with aiohttp.ClientSession() as session:
async with session.get(url) as resp:
return await resp.text()

async def main():
urls = ['http://example.com'] * 10
results = await asyncio.gather(*(io_task(url) for url in urls))
print(results)

asyncio.run(main())

Итог:

• Для CPU-bound-задач следует выбирать параллелизм на основе процессов (multiprocessing), поскольку этого требует GIL
• Для IO-bound-задач подходит асинхронность через asyncio: неблокирующее IO позволяет эффективнее использовать время выполнения
• Такое разделение помогает рационально задействовать ресурсы и сократить время выполнения Python-задач

Подробный ответ

Основной ответ

Для обработки CPU-bound-задач в Python чаще всего выбирают мультипроцессинг (модуль multiprocessing). Глобальная блокировка интерпретатора (GIL) ограничивает параллельное выполнение потоков при CPU-интенсивных вычислениях. Для IO-bound-задач можно использовать многопоточность (threading) либо асинхронный код (asyncio): такие задачи значительную часть времени проводят в ожидании ввода-вывода, поэтому GIL не препятствует эффективному параллельному выполнению.

В описанном случае — при наличии 10 CPU-bound и 10 IO-bound задач — обработку лучше разделить следующим образом:

1. Запустите пул процессов (multiprocessing.Pool) и распределите между ним 10 CPU-bound-задач, чтобы задействовать доступные ядра CPU.
2. Для 10 IO-bound-задач выберите concurrent.futures.ThreadPoolExecutor или asyncio — решение зависит от типа IO, например сетевых запросов или файловых операций.

Ключевые моменты

• GIL и CPU-bound-задачи: GIL в Python допускает одновременное выполнение байт-кода только одним потоком. Поэтому потоки не ускоряют CPU-интенсивную работу — для неё требуется параллелизм на уровне процессов.
• IO-bound-задачи не блокируют GIL: во время ожидания ввода-вывода поток освобождает GIL, благодаря чему другие потоки могут продолжать работу и повышать общую производительность.
• Асинхронность vs Потоки: asyncio эффективнее при большом числе коротких IO-задач, ожидающих результат, например множества HTTP-запросов. Потоки при этом проще подключать к blocking IO.

Практический контекст

В качестве CPU-bound-примера можно взять вычисление больших чисел с использованием пула процессов (multiprocessing.Pool.map). Для IO-bound-сценария подойдёт параллельная загрузка страниц по HTTP через ThreadPoolExecutor или связку asyncio + aiohttp.

Такое решение позволяет наиболее полно использовать системные ресурсы: CPU получает постоянную нагрузку при тяжёлых вычислениях, а операции IO не становятся узким местом и не блокируют вычислительную работу. В продакшене эти механизмы нередко объединяют, например используя очереди задач (celery) и балансируя нагрузку.