Может ли синхронный код работать быстрее асинхронного?

Может ли синхронный код работать быстрее асинхронного?

Да, абсолютно может. Это один из самых распространённых мифов в программировании. Асинхронный код не всегда быстрее синхронного, и в некоторых случаях синхронный код показывает лучшую производительность.

1. Когда синхронный код может быть быстрее

Отсутствие I/O операций

Если вы работаете только с CPU-bound операциями (обработка данных, вычисления), синхронный код будет быстрее из-за отсутствия оверхеда асинхронности:

import time

# Синхронный код
def cpu_bound_sync():
    result = 0
    for i in range(100_000_000):
        result += i * i
    return result

# Асинхронный код (медленнее!)
async def cpu_bound_async():
    result = 0
    for i in range(100_000_000):
        result += i * i
    return result

# Синхронный быстрее на 10-20% из-за оверхеда асинхронности
start = time.time()
cpu_bound_sync()
print(f'Sync: {time.time() - start:.2f}s')

start = time.time()
await cpu_bound_async()
print(f'Async: {time.time() - start:.2f}s')

2. Оверхед асинхронности

Асинхронный код имеет накладные расходы:

• Context switching — переключение между корутинами
• Event loop overhead — управление циклом событий
• Memory — больше памяти на каждую корутину
• Сложность отладки — сложнее профилировать и отлаживать

import asyncio
import time

# Простая синхронная функция
def sync_add(a, b):
    return a + b

# Простая асинхронная функция
async def async_add(a, b):
    return a + b

# Синхронный код быстрее
start = time.time()
for _ in range(1_000_000):
    sync_add(1, 1)
print(f'Sync: {time.time() - start:.2f}s')  # ~0.03s

start = time.time()
asyncio.run(call_async_many())
print(f'Async: {time.time() - start:.2f}s')  # ~0.5s

3. Когда асинхронный код даёт преимущество

I/O-bound операции с множественными запросами

Асинхронный код превосходит синхронный при работе с несколькими I/O операциями одновременно:

import asyncio
import time
import aiohttp
import requests

# Синхронный код — ждёт каждый запрос
def fetch_sync(urls):
    results = []
    for url in urls:
        response = requests.get(url)
        results.append(response.status_code)
    return results

# Асинхронный код — параллельные запросы
async def fetch_async(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [session.get(url) for url in urls]
        results = await asyncio.gather(*tasks)
        return [r.status for r in results]

# Тест с 10 URL-ами
urls = ['https://example.com'] * 10

start = time.time()
fetch_sync(urls)
print(f'Sync: {time.time() - start:.2f}s')  # ~10 сек

start = time.time()
asyncio.run(fetch_async(urls))
print(f'Async: {time.time() - start:.2f}s')  # ~1 сек

4. Сравнение: реальные числа

Сценарий 1: CPU-bound (100 млн итераций)

Sync:  0.45s
Async: 0.52s (15% медленнее)

Сценарий 2: 10 HTTP запросов (0.5s каждый)

Sync:  5.0s (последовательно)
Async: 0.5s (параллельно)

Сценарий 3: Одна простая операция

Sync:  0.001ms
Async: 0.050ms (50x медленнее)

5. Когда выбирать что?

Используй синхронный код, если:

• Нет I/O операций
• Только одна операция за раз
• Нужна максимальная простота и отладка
• CPU-bound вычисления

# Хороший синхронный код
def calculate_statistics(data):
    return {
        'mean': sum(data) / len(data),
        'max': max(data),
        'min': min(data)
    }

Используй асинхронный код, если:

• Множественные I/O операции
• Нужна высокая concurrency (1000+ одновременных соединений)
• Работа с WebSockets или real-time приложения
• Database queries с ожиданием

# Хороший асинхронный код
async def fetch_all_users():
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_user(session, user_id) for user_id in user_ids]
        return await asyncio.gather(*tasks)

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

Используй оба подхода в одном приложении:

import asyncio
from concurrent.futures import ThreadPoolExecutor

# CPU-bound функция в отдельном потоке
loop = asyncio.get_event_loop()
executor = ThreadPoolExecutor()

async def main():
    # I/O операции асинхронно
    data = await fetch_data()  # async
    
    # CPU операции в потоке
    result = await loop.run_in_executor(executor, cpu_intensive, data)
    
    return result

7. Профилирование

Никогда не угадывай — профилируй:

import cProfile
import asyncio

# Профилирование синхронного кода
cProfile.run('sync_function()')

# Профилирование асинхронного кода
python -m cProfile -s cumtime your_script.py

8. Конкретные примеры ошибок

Ошибка: использование async для CPU-bound кода

# ПЛОХО
async def bad_calculation():
    for i in range(100_000_000):
        x = i ** 2
    return x

# ХОРОШО
def good_calculation():
    for i in range(100_000_000):
        x = i ** 2
    return x

Ошибка: не ждать множественных асинхронных операций

# ПЛОХО - выполняется последовательно
async def bad():
    await fetch(url1)
    await fetch(url2)
    await fetch(url3)

# ХОРОШО - выполняется параллельно
async def good():
    await asyncio.gather(
        fetch(url1),
        fetch(url2),
        fetch(url3)
    )

Вывод

• Синхронный код быстрее для: чистых вычислений, простых операций, отсутствия I/O
• Асинхронный код быстрее для: множественных I/O операций, concurrency, real-time приложений
• Оверхед асинхронности реален: 10-50% медленнее для простых операций
• Выбирай инструмент под задачу: не усложняй без необходимости

Помни: правильный выбор архитектуры важнее, чем синхронный vs асинхронный.