PrepBro
← Назад к вопросам

Зачем нужен connection pool?

2.0 Middle🔥 121 комментариев
#Архитектура и паттерны#Базы данных (SQL)

Комментарии (1)

🐱
claude-haiku-4.5PrepBro AI22 мар. 2026 г.(ред.)

Ответ сгенерирован нейросетью и может содержать ошибки

Зачем нужен Connection Pool и как это улучшает производительность

Connection Pool (пул соединений) — это паттерн управления дорогостоящими ресурсами, такими как соединения с базой данных. Это критично для масштабирования приложений.

Проблема: создание соединения — дорого

Создание нового соединения с БД требует нескольких шагов:

  1. Установка TCP соединения с сервером (handshake)
  2. Аутентификация (проверка логина и пароля)
  3. Инициализация сессии (установка параметров, кодировки)
  4. Выделение памяти на сервере
Класс: ~100-500 мс на создание одного соединения!

Если каждый запрос создаёт новое соединение:

# ❌ ПЛОХО: создаём соединение для каждого запроса
from flask import Flask
import psycopg2

app = Flask(__name__)

@app.route('/user/<user_id>')
def get_user(user_id):
    # Каждый запрос — 100-500ms на соединение!
    conn = psycopg2.connect(
        dbname='myapp',
        user='postgres',
        password='secret',
        host='localhost'
    )
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM users WHERE id = %s', (user_id,))
    user = cursor.fetchone()
    cursor.close()
    conn.close()
    return user

При 100 одновременных запросах:

  • Время на создание соединений: 100 × 200ms = 20 секунд
  • Время на запросы: может быть всего 10ms

Результат: 99.5% времени потрачено на соединения, а не на данные!

Решение: Connection Pool

Пул заранее создаёт и переиспользует соединения:

# ✅ ХОРОШО: переиспользуем соединения из пула
from psycopg2 import pool

connection_pool = pool.SimpleConnectionPool(
    1,          # минимум соединений
    20,         # максимум соединений
    dbname='myapp',
    user='postgres',
    password='secret',
    host='localhost'
)

@app.route('/user/<user_id>')
def get_user(user_id):
    conn = connection_pool.getconn()  # Получаем из пула (0ms!) или создаём
    try:
        cursor = conn.cursor()
        cursor.execute('SELECT * FROM users WHERE id = %s', (user_id,))
        user = cursor.fetchone()
        cursor.close()
    finally:
        connection_pool.putconn(conn)  # Возвращаем в пул
    return user

Теперь:

  • При первых 20 запросах создаются соединения (200ms × 20 = 4s)
  • При следующих запросах используются существующие соединения (0ms!)
  • Производительность повышается в 10-100 раз

Как работает Pool

Пул с min=5, max=20:

┌─────────────────────────────────────────┐
│          Connection Pool                │
├─────────────────────────────────────────┤
│ [conn1]  [conn2]  [conn3]  [conn4]      │ Свободные соединения
│ [conn5]  [waiting...]			        │
│ [active_request_1] [active_request_2]   │ Активные
│ [active_request_3]                      │ 
│				                    │
│ Занято: 3, Свободно: 2, Max: 20	│
└─────────────────────────────────────────┘

Когда приходит новый запрос:

  1. Проверяем свободные соединения в пуле
  2. Если есть — выдаём его (0ms)
  3. Если нет, но не достигли max — создаём новое (200-500ms)
  4. Если max достигнут — ждём освобождения (очередь)

Практический пример с SQLAlchemy

Самый распространённый способ в Python:

from sqlalchemy import create_engine
from sqlalchemy.pool import QueuePool

# Конфигурация пула
engine = create_engine(
    'postgresql://user:password@localhost/dbname',
    poolclass=QueuePool,
    pool_size=10,          # Количество соединений в пуле
    max_overflow=20,       # Как много дополнительных можно создать
    pool_recycle=3600,     # Переиспользовать соединение макс 1 час
    pool_pre_ping=True,    # Проверять живо ли соединение
    echo=False             # Логировать SQL (для отладки)
)

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)

# Использование
def get_user(user_id):
    session = Session()
    try:
        user = session.query(User).filter(User.id == user_id).first()
        return user
    finally:
        session.close()  # Возвращает соединение в пул

Параметры пула и их смысл

engine = create_engine(
    'postgresql://...',
    # pool_size: базовое количество соединений, которые создаются сразу
    pool_size=10,
    
    # max_overflow: сколько дополнительных можно создать сверх pool_size
    # Если pool_size=10, max_overflow=20, то макс 30 соединений
    max_overflow=20,
    
    # pool_timeout: как долго ждать свободного соединения (в секундах)
    pool_timeout=30,
    
    # pool_recycle: переиспользовать соединение максимум N секунд
    # Некоторые базы отключают idle соединения (~900s)
    pool_recycle=3600,
    
    # pool_pre_ping: проверять соединение перед использованием
    # Выполняет ping-запрос, чтобы убедиться, что оно живо
    pool_pre_ping=True,
    
    # echo: логировать все SQL запросы
    echo=False
)

Мониторинг пула

def check_pool_status(engine):
    pool = engine.pool
    print(f"Pool size: {pool.size()}")
    print(f"Checked-in connections: {pool.checkedin()}")
    print(f"Overflow: {pool.overflow()}")
    print(f"Disconnected: {pool.disconnect()}")

@app.route('/pool-status')
def pool_status():
    check_pool_status(engine)
    return "See logs"

Проблемы и решения

Проблема 1: Истощение пула (Pool Exhaustion)

# ❌ ПЛОХО: соединение не возвращается в пул
def bad_query():
    session = Session()
    result = session.query(User).all()
    return result  # session не закрыт!
    # Со временем все соединения в пуле будут исчерпаны

# ✅ ХОРОШО: соединение возвращается
def good_query():
    session = Session()
    try:
        result = session.query(User).all()
        return result
    finally:
        session.close()  # Гарантированно закроется

# ✅ ЛУЧШЕ: контекстный менеджер
def best_query():
    with Session() as session:
        result = session.query(User).all()
        return result  # Автоматически закроется

Проблема 2: Мёртвые соединения

База может отключить неиспользуемое соединение (обычно ~900 секунд).

# ❌ ПЛОХО: соединение может быть мёртвым
conn = pool.getconn()
time.sleep(1000)  # Долго ничего не делали
conn.query("SELECT 1")  # ❌ Ошибка: connection lost

# ✅ ХОРОШО: pool_pre_ping проверит живо ли соединение
engine = create_engine('postgresql://...', pool_pre_ping=True)

# ✅ ЛУЧШЕ: pool_recycle переиспользует соединение
engine = create_engine('postgresql://...', pool_recycle=3600)

Проблема 3: Thread safety

Соединения должны использоваться в том же потоке, где были получены.

# ❌ ОПАСНО: передаём соединение между потоками
import threading

conn = pool.getconn()

def worker():
    conn.query("SELECT 1")  # ❌ Может быть race condition

thread = threading.Thread(target=worker)
thread.start()

# ✅ ХОРОШО: каждый поток получает своё соединение
def worker():
    with Session() as session:
        session.query(User).all()

thread = threading.Thread(target=worker)
thread.start()

Практический пример: FastAPI с пулом

from fastapi import FastAPI
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, Session
from typing import Generator

app = FastAPI()

engine = create_engine(
    'postgresql://user:password@localhost/db',
    pool_size=10,
    max_overflow=20,
    pool_pre_ping=True,
    pool_recycle=3600
)

SessionLocal = sessionmaker(bind=engine)

def get_db() -> Generator[Session, None, None]:
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()  # Возвращает в пул

@app.get('/users/{user_id}')
def get_user(user_id: int, db: Session = Depends(get_db)):
    user = db.query(User).filter(User.id == user_id).first()
    return user

@app.get('/pool-status')
def pool_status():
    return {
        'size': engine.pool.size(),
        'checked_in': engine.pool.checkedin(),
        'overflow': engine.pool.overflow()
    }

Выводы и лучшие практики

Почему нужен Connection Pool:

  • Создание соединения дорого (~100-500ms)
  • Переиспользование экономит время и ресурсы
  • Контролирует нагрузку на БД
  • Улучшает отзывчивость приложения

Правила использования:

  1. Всегда используй пул, даже для малых приложений
  2. Закрывай соединения в try/finally или используй контекстные менеджеры
  3. Мониторь использование пула (размер, очередь)
  4. Используй pool_pre_ping для проверки живых соединений
  5. Устанавливай pool_recycle для долгоживущих приложений
  6. Не держи соединения открытыми дольше, чем нужно

Пул соединений — это не роскошь, это необходимость для любого production приложения.

Зачем нужен connection pool? | PrepBro