為什麼需要數據庫連接池？Django 性能優化的關鍵

import time
import psycopg2

# 測試：建立 100 次 PostgreSQL 連接
start = time.time()
for i in range(100):
    conn = psycopg2.connect(
        host='localhost',
        database='mydb',
        user='postgres',
        password='password'
    )
    conn.close()
end = time.time()

print(f'建立 100 次連接耗時: {end - start:.2f} 秒')
print(f'平均每次連接: {(end - start) / 100 * 1000:.2f} 毫秒')

本地數據庫：
  建立 100 次連接耗時: 2.34 秒
  平均每次連接: 23.4 毫秒

跨區域數據庫（網絡延遲 50ms）：
  建立 100 次連接耗時: 7.82 秒
  平均每次連接: 78.2 毫秒

# Django 默認的連接管理（每次請求）
┌─────────────────────────────────────────────┐
│  HTTP 請求到達                               │
│       │                                      │
│       ▼                                      │
│  建立數據庫連接  ──────► ~20ms               │
│       │                                      │
│       ▼                                      │
│  執行 SQL 查詢  ────────► ~5ms               │
│       │                                      │
│       ▼                                      │
│  關閉數據庫連接  ──────► ~2ms                │
│       │                                      │
│       ▼                                      │
│  返回 HTTP 響應                              │
│                                              │
│  總耗時：~27ms（其中 20ms 浪費在連接上）    │
│  浪費比例：74%                               │
└─────────────────────────────────────────────┘

# 場景：電商秒殺，瞬間 1000 個請求

┌────────────────────────────────────────────┐
│  1000 個請求同時到達                        │
│       │                                     │
│       ▼                                     │
│  嘗試建立 1000 個數據庫連接                │
│       │                                     │
│       ▼                                     │
│  PostgreSQL max_connections = 100 (默認)   │
│       │                                     │
│       ▼                                     │
│  ❌ 900 個請求失敗：                        │
│     "FATAL: too many connections"          │
│                                             │
│  ❌ 剩下 100 個請求：                       │
│     建立連接耗時 20ms × 100 = 2000ms       │
│     CPU 和內存飆升                          │
└────────────────────────────────────────────┘

# Django View
def product_detail(request, pk):
    product = Product.objects.get(pk=pk)
    return JsonResponse({'name': product.name})

# 高並發時的錯誤
psycopg2.OperationalError: FATAL: sorry, too many clients already

import concurrent.futures
import psycopg2
import time

def make_request():
    start = time.time()
    try:
        conn = psycopg2.connect(
            host='localhost',
            database='mydb',
            user='postgres',
            password='password'
        )
        cursor = conn.cursor()
        cursor.execute('SELECT COUNT(*) FROM products')
        result = cursor.fetchone()
        conn.close()
        return time.time() - start
    except Exception as e:
        return None

# 100 並發
with concurrent.futures.ThreadPoolExecutor(max_workers=100) as executor:
    results = list(executor.map(make_request, range(100)))

successful = [r for r in results if r is not None]
failed = len(results) - len(successful)

print(f'成功: {len(successful)}, 失敗: {failed}')
print(f'平均響應時間: {sum(successful) / len(successful):.3f}s')

成功: 62 個請求
失敗: 38 個請求（連接被拒絕）
成功率: 62%
平均響應時間: 1.245 秒

數據庫服務器狀態:
  連接數: 98/100（接近上限）
  CPU 使用率: 85%
  內存使用: 12.5%

-- PostgreSQL 錯誤日誌
ERROR: sorry, too many clients already

# ❌ 錯誤示例：忘記關閉連接
from django.db import connection

def bad_view(request):
    cursor = connection.cursor()
    cursor.execute('SELECT * FROM products')
    products = cursor.fetchall()

    # ❌ 忘記關閉 cursor 或 connection
    # ❌ 如果中間拋出異常，連接永遠不會釋放

    return JsonResponse({'products': products})

# 結果：
# 1. 每次請求都創建連接，但不釋放
# 2. 數據庫連接數持續增長
# 3. 最終達到 max_connections 上限
# 4. 所有後續請求失敗

-- PostgreSQL：查看當前連接
SELECT
    pid,
    usename,
    application_name,
    state,
    state_change,
    NOW() - state_change AS duration
FROM pg_stat_activity
WHERE state = 'idle'
ORDER BY duration DESC;

-- 發現：大量 idle 連接超過 10 分鐘
 pid  | usename | state |      duration
------+---------+-------+---------------------
12345 | django  | idle  | 00:15:23.456789  ← 洩漏！
12346 | django  | idle  | 00:12:18.123456  ← 洩漏！

✅ 連接已經建立好：
   省去 20ms 建立時間
   省去身份驗證過程
   省去連接初始化

✅ 連接可以重用：
   避免重複建立/關閉
   減少數據庫負擔
   提升響應速度

✅ 限制最大連接數：
   保護數據庫不過載
   防止連接數超限
   可預測的資源使用

✅ 自動管理生命週期：
   防止連接洩漏
   定期健康檢查
   自動回收過期連接

# 每次請求
def get_product(request, pk):
    # 1. 建立連接       ~20ms
    # 2. 執行查詢       ~5ms
    # 3. 關閉連接       ~2ms
    product = Product.objects.get(pk=pk)
    return JsonResponse({'name': product.name})

# 總耗時：~27ms

# 每次請求
def get_product(request, pk):
    # 1. 從池中獲取連接  ~0.1ms
    # 2. 執行查詢        ~5ms
    # 3. 歸還連接到池    ~0.1ms
    product = Product.objects.get(pk=pk)
    return JsonResponse({'name': product.name})

# 總耗時：~5.2ms（提升 5 倍！）

import time
from django.db import connection
from products.models import Product

# 測試 1：無連接池（Django 默認）
CONN_MAX_AGE = 0  # 每次請求後關閉連接
start = time.time()
for i in range(1000):
    Product.objects.get(pk=1)
    connection.close()  # 強制關閉
time_no_pool = time.time() - start

# 測試 2：持久連接（模擬連接池）
CONN_MAX_AGE = 600  # 連接保持 10 分鐘
start = time.time()
for i in range(1000):
    Product.objects.get(pk=1)
time_with_pool = time.time() - start

print(f'無連接池: {time_no_pool:.2f}s')
print(f'有連接池: {time_with_pool:.2f}s')
print(f'性能提升: {time_no_pool / time_with_pool:.1f}x')

無連接池: 24.35 秒
有連接池: 4.82 秒
性能提升: 5.1 倍

$ ab -n 1000 -c 100 http://localhost:8000/api/products/1/

# 無連接池：
Requests per second:    41.23 [#/sec]
Time per request:       2426.43 [ms]
Failed requests:        387 (too many connections)
成功率: 61%

# 有連接池（pool_size=20）：
Requests per second:    246.18 [#/sec]
Time per request:       406.21 [ms]
Failed requests:        0
成功率: 100%

# 性能提升：6 倍，成功率從 61% → 100%

# settings.py（Django 默認）
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydb',
        'USER': 'postgres',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '5432',

        # ⚠️ 關鍵參數：默認值
        'CONN_MAX_AGE': 0,  # 每次請求後關閉連接
    }
}

CONN_MAX_AGE = 0 時：
  Request 開始: 建立數據庫連接
  執行查詢: 使用連接
  Request 結束: 關閉連接 ← 每次都關閉！

問題：
  - 無連接重用
  - 等同於 Django 1.5 之前的行為
  - 性能最差

# settings.py
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydb',
        'USER': 'postgres',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '5432',

        # ✅ 啟用持久連接
        'CONN_MAX_AGE': 600,  # 連接保持 600 秒（10 分鐘）
    }
}

CONN_MAX_AGE = 600 時：
  Request 1:
    - 建立數據庫連接
    - 執行查詢
    - Request 結束 → 保持連接（不關閉）← 重用！

  Request 2（同一個 Worker）:
    - 重用現有連接 ← 省去 20ms！
    - 執行查詢
    - Request 結束 → 保持連接

  601 秒後:
    - 連接超過 CONN_MAX_AGE → 關閉
    - 下次請求重新建立

優勢：
  - Worker 內連接重用
  - 提升響應速度
  - 簡單易用

限制：
  - 每個 Worker 只有 1 個連接
  - 無法跨進程共享
  - 不是真正的連接池

# Gunicorn 4 個 Worker
$ gunicorn -w 4 myproject.wsgi:application

# 每個 Worker 獨立維護連接
Worker 1 ─► Connection 1 (獨立)
Worker 2 ─► Connection 2 (獨立)
Worker 3 ─► Connection 3 (獨立)
Worker 4 ─► Connection 4 (獨立)

# ⚠️ 問題：
1. 總連接數 = Worker 數 × 數據庫數
   - 4 Workers × 2 數據庫 = 8 連接（最少）

2. 高並發時仍會創建新連接
   - Worker 1 正在使用連接
   - 同一 Worker 的新請求需要等待或創建新連接

3. 連接利用率低
   - Worker 閒置時，連接也閒置
   - 無法跨 Worker 共享連接