В чем разница между асинхронным и синхронным сервером?

Разница между асинхронным и синхронным сервером

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

Синхронный сервер

Синхронный сервер обрабатывает запросы последовательно: он ждёт завершения операции, прежде чем приступить к следующей.

Как это работает:

# Синхронный код (Flask с Gunicorn)
from flask import Flask
import time

app = Flask(__name__)

@app.route("/api/data")
def get_data():
    # Имитация долгой операции (например, запрос к БД)
    time.sleep(2)
    return {"data": "result"}

if __name__ == "__main__":
    app.run()  # Работает с синхронным WSGI сервером

Архитектура:

• 1 запрос → 1 поток/процесс
• Поток блокируется во время I/O операций (чтение файла, запрос к БД, HTTP запрос)
• Максимум одновременных запросов = количество потоков/процессов

Пример обработки 3 запросов на синхронном сервере с 2 потоками:

Поток 1: Запрос 1 (0-2s) → Запрос 3 (2-4s)
Поток 2: Запрос 2 (0-2s)

Общее время: 4 секунды
Одновременно обрабатывается: max 2 запроса

Асинхронный сервер

Асинхронный сервер может обрабатывать множество запросов в одном потоке благодаря event loop. Когда операция блокирует, сервер переходит на следующий запрос.

Как это работает:

# Асинхронный код (FastAPI с Uvicorn)
from fastapi import FastAPI
import asyncio

app = FastAPI()

@app.get("/api/data")
async def get_data():
    # Асинхронная операция НЕ блокирует поток
    await asyncio.sleep(2)
    return {"data": "result"}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app)  # Асинхронный ASGI сервер

Архитектура:

• 1 event loop → N одновременных запросов
• Во время I/O операции event loop переключается на другой запрос
• Нет блокирующих операций
• Максимум запросов ограничен памятью, а не потоками

Пример обработки 3 запросов на асинхронном сервере с 1 потоком:

Эvent Loop:
0-0.1s: Запрос 1 начат (await sleep 2)
0-0.2s: Запрос 2 начат (await sleep 2)
0-0.3s: Запрос 3 начат (await sleep 2)
2-2.1s: Запрос 1 завершён
2-2.2s: Запрос 2 завершён
2-2.3s: Запрос 3 завершён

Общее время: ~2 секунды
Одновременно обрабатывается: 3+ запроса

Ключевые различия

Сравнение производительности

# Синхронный сервер (каждый поток ждёт 2 секунды)
# 10 одновременных запросов × 2 сек = 20 секунд
# Нужно 10 потоков

Gunicorn workers: 10
Общая память: ~500 МБ
Общее время ответа: 2 сек на запрос

# Асинхронный сервер (все запросы в одном потоке)
# 10 одновременных запросов × 2 сек = 2 секунды
# Нужен 1 поток

Uvicorn workers: 1
Общая память: ~50 МБ
Общее время ответа: 2 сек на запрос

Блокирующие операции

Синхронный сервер:

import requests

def sync_handler():
    # Блокирует поток на 2 секунды
    response = requests.get("https://api.example.com/data", timeout=2)
    return response.json()

Асинхронный сервер:

import aiohttp

async def async_handler():
    # НЕ блокирует поток
    async with aiohttp.ClientSession() as session:
        async with session.get("https://api.example.com/data") as resp:
            return await resp.json()

Когда использовать что

Синхронный сервер подходит для:

• Приложений с невысокой нагрузкой (< 1000 одновременных пользователей)
• Когда блокирующие операции неизбежны (например, синхронный драйвер БД)
• Простых CRUD приложений
• Когда команда не имеет опыта с async

Асинхронный сервер подходит для:

• High-load приложений с тысячами одновременных соединений
• I/O heavy приложений (микросервисы, API гейтвеи)
• Real-time функционала (WebSockets, SSE)
• Сервисов, которые часто обращаются к внешним API

В заключение: асинхронные серверы более эффективны для современных нагрузок, но требуют понимания async/await и неблокирующего кода.