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

Выбор инструмента многозадачности для подписывания документов

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

Threading (потоки)

Когда использовать: Когда операция подписывания — это I/O-bound задача (сетевой запрос к сервису подписей, чтение файла).

import threading
from concurrent.futures import ThreadPoolExecutor

def sign_document(document_path, private_key):
    # I/O операция: чтение файла, отправка на сервис
    with open(document_path, "rb") as f:
        data = f.read()
    signature = request_signature_service(data, private_key)
    return signature

# Подписываем несколько документов параллельно
with ThreadPoolExecutor(max_workers=5) as executor:
    documents = ["doc1.pdf", "doc2.pdf", "doc3.pdf"]
    futures = [executor.submit(sign_document, doc, key) for doc in documents]
    results = [f.result() for f in futures]

Преимущества: Простая реализация, хорошо подходит для I/O-bound задач, GIL не мешает при ожидании I/O.

Недостатки: Не подходит для CPU-bound операций из-за GIL (Global Interpreter Lock).

Multiprocessing (процессы)

Когда использовать: Когда подписывание требует интенсивных вычислений (например, криптографические операции).

from multiprocessing import Pool
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import rsa, padding

def sign_with_crypto(document_data):
    """CPU-bound операция: криптографическое подписывание"""
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048,
    )
    signature = private_key.sign(
        document_data,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    return signature

# Подписываем несколько документов в разных процессах
with Pool(processes=4) as pool:
    documents = [b"data1", b"data2", b"data3"]
    signatures = pool.map(sign_with_crypto, documents)

Преимущества: Обходит GIL, отличная производительность для CPU-bound задач.

Недостатки: Высокие overhead на создание процессов, сложнее отладить, невозможно делиться состоянием без специальных механизмов.

Asyncio (асинхронность)

Когда использовать: Когда нужно подписать много документов параллельно и все операции — это I/O (HTTP запросы к API сервиса подписей).

import asyncio
import aiohttp

async def sign_document_async(session, document_id, private_key):
    """Подписываем через API асинхронно"""
    async with session.post(
        "https://signing-service.com/sign",
        json={"document_id": document_id, "key": private_key}
    ) as response:
        return await response.json()

async def sign_batch(documents):
    async with aiohttp.ClientSession() as session:
        tasks = [
            sign_document_async(session, doc_id, key)
            for doc_id, key in documents
        ]
        return await asyncio.gather(*tasks)

# Использование
results = asyncio.run(sign_batch([("doc1", "key1"), ("doc2", "key2")]))

Преимущества: Отличная масштабируемость для I/O, одного потока достаточно для 1000+ операций, низкие overhead.

Недостатки: Более сложная в освоении, требует асинхронного кода по всей цепочке.

Рекомендация

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

1. ThreadPoolExecutor — если подписывание через HTTP API (I/O-bound)
2. Asyncio — если нужна максимальная масштабируемость (1000+ документов)
3. Multiprocessing — если используется локальное криптографическое подписывание с CPU-интенсивными операциями
4. Комбинированный подход — asyncio для управления очередью + multiprocessing для тяжелых крипто-операций

В большинстве реальных сценариев документооборота рекомендую asyncio + aiohttp, так как операции обычно идут к удаленным сервисам подписей.