Как решается I/O bound задача?

Решение I/O bound задач в Python

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

1. Многопоточность (Threading)

Это первый выбор для I/O bound задач в Python:

import threading
import requests
from concurrent.futures import ThreadPoolExecutor

def fetch_url(url):
    response = requests.get(url)
    return response.status_code

# Решение 1: Использование ThreadPoolExecutor
with ThreadPoolExecutor(max_workers=10) as executor:
    urls = [http://example.com/api/1, http://example.com/api/2]
    results = list(executor.map(fetch_url, urls))
    print(results)

Преимущества:

• Просто использовать
• Хорошо подходит для большого числа одновременных операций
• GIL не проблема для I/O операций

Недостатки:

• Overhead на создание потоков (для тысяч операций)
• Сложнее с отладкой

2. Асинхронное программирование (asyncio)

Более эффективный подход для высокой параллелизации:

import asyncio
import aiohttp

async def fetch_url(session, url):
    async with session.get(url) as response:
        return response.status

async def main():
    urls = [http://example.com/api/1, http://example.com/api/2]
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        print(results)

asyncio.run(main())

Преимущества:

• Малый overhead памяти (10000+ параллельных операций)
• Высокая производительность
• Event loop обрабатывает много операций в одном потоке

Недостатки:

• Более сложный код
• Нужна поддержка async в библиотеках (asyncio-совместимые)
• Сложнее отлаживать

3. Асинхронность с процессом (multiprocessing)

Для случаев, когда операция требует отдельного процесса:

from concurrent.futures import ProcessPoolExecutor
import subprocess

def run_command(cmd):
    result = subprocess.run(cmd, capture_output=True, text=True)
    return result.stdout

with ProcessPoolExecutor(max_workers=4) as executor:
    commands = [ls, pwd, whoami]
    results = list(executor.map(run_command, commands))

4. Гибридный подход

Для максимальной производительности часто комбинируют подходы:

from concurrent.futures import ThreadPoolExecutor
import asyncio

async def fetch_with_thread(url):
    loop = asyncio.get_event_loop()
    with ThreadPoolExecutor() as executor:
        # Блокирующая операция в отдельном потоке
        result = await loop.run_in_executor(executor, requests.get, url)
        return result.status_code

Сравнение подходов

Практические рекомендации

1. Для простых случаев (10-50 параллельных операций) - используй ThreadPoolExecutor
2. Для высоконагруженных систем (1000+) - переходи на asyncio
3. Для смешанных нагрузок - комбинируй подходы
4. Используй библиотеки: aiohttp (HTTP), asyncpg (PostgreSQL), aioredis (Redis)

В production обязательно:

• Устанавливай таймауты на I/O операции
• Используй пулы соединений
• Мониторь количество открытых соединений
• Внедряй retry логику с exponential backoff