Почему Redis настолько быстро работает?

Почему Redis настолько быстро работает

Redis — это одна из самых быстрых систем хранения данных. Давайте разберемся почему:

1. In-Memory хранилище

Самая главная причина — Redis работает в памяти RAM, а не на диске:

# Сравнение скорости
# RAM:        ~10 наносекунд для доступа
# SSD:        ~1 микросекунду (в 100 раз медленнее)
# HDD:        ~10 миллисекунд (в миллион раз медленнее)

# Redis GET/SET: <1 микросекунда (100,000+ операций в секунду)
# PostgreSQL: ~5-10 миллисекунд (1000-2000 операций в секунду)

Операция в памяти в миллионы раз быстрее чем дисковая операция.

2. Однопоточная архитектура с event loop

Redis работает в одном потоке, но очень эффективно:

Редис использует event loop (как Node.js, asyncio):

┌─────────────────────────────────────────┐
│        Event Loop (1 поток)              │
├─────────────────────────────────────────┤
│ 1. Получить запрос от клиента           │
│ 2. Обработать (читать/писать в памяти)  │
│ 3. Отправить ответ                      │
│ 4. Следующий запрос                     │
│                                         │
│ ВСЁ ЗА НАНОСЕКУНДЫ!                    │
└─────────────────────────────────────────┘

Без создания потоков, без контекстных переключений.

Преимущества:

• Нет overhead от создания потоков
• Нет race conditions внутри Redis
• Нет GC паузы из-за большого количества объектов
• Очень предсказуемая задержка

3. Простые структуры данных

Redis использует оптимизированные структуры данных:

# String — просто байты в памяти
redis.set("user:1:name", "Alice")  # Просто memcpy

# Hash — оптимизированная hash-таблица
redis.hset("user:1", "name", "Alice")  # O(1) для доступа
redis.hset("user:1", "email", "alice@mail.com")

# List — оптимизированный doubly-linked list
redis.rpush("queue:tasks", task1)  # O(1) добавление

# Set — hash-таблица без значений
redis.sadd("user:1:tags", "developer")  # O(1)

# Sorted Set — skip list + hash table
redis.zadd("leaderboard", {"alice": 100})  # O(log N)

Все операции либо O(1), либо O(log N) — очень быстро.

4. Zero-copy операции

Redis минимизирует копирование данных:

❌ PostgreSQL (копирует):
Данные на диске → буфер → парсинг → объект → ответ
    (4+ копирования)

✓ Redis (minimal copy):
Данные в памяти → прямой указатель → отправить
    (1 копирование в сетевой буфер)

Использует указатели вместо копирования.

5. Очень эффективная сетевая обработка

Redis использует epoll/kqueue для тысяч одновременных соединений:

┌──────────────────────────────────────┐
│  epoll (Linux) / kqueue (BSD)        │
├──────────────────────────────────────┤
│  1000+ одновременных соединений      │
│  Без создания потока на соединение    │
│  Минимальный overhead                │
└──────────────────────────────────────┘

6. Простой протокол (RESP)

Redis использует очень простой текстовый протокол (RESP):

Структура RESP очень простая для парсинга:

*2\r\n        <- массив из 2 элементов
$3\r\n        <- строка из 3 байт
GET\r\n       <- команда
$4\r\n        <- строка из 4 байт
key1\r\n      <- ключ

Парсится за O(n), где n = длина запроса
Нет сложного парсинга как в JSON

7. No Garbage Collection паузы

Redis написан на C, без GC:

❌ Python/Java сервер:
1. Работает нормально
2. GC запускается — СТОП на 100-500мс
3. Все клиенты ждут

✓ Redis (C, no GC):
1. Работает нормально
2. Никогда не стопается
3. Предсказуемая задержка <1мкс

8. Persistence может быть асинхронной

Визу данных на диск происходит в фоновом потоке:

# В памяти: мгновенно
redis.set("key", "value")  # <1мкс

# На диск: в фоне (RDB или AOF)
# Не блокирует основной цикл

# Результат: очень быстро в памяти, дurable на диске

9. Батчинг запросов

Клиент может отправить несколько команд сразу:

# Pipeline — отправляет несколько команд за раз
pipe = redis.pipeline()
pipe.set("key1", "value1")
pipe.set("key2", "value2")
pipe.set("key3", "value3")
results = pipe.execute()  # Все обработаны за одно RTT

# Без pipeline: 3 RTT (round trips) = медленнее

10. Lua скрипты (атомарные операции)

Люа скрипты выполняются атомарно в одном цикле:

# Атомарное увеличение счётчика
script = """
local current = redis.call('GET', KEYS[1])
if not current then
  redis.call('SET', KEYS[1], 1)
else
  redis.call('SET', KEYS[1], current + 1)
end
"""

result = redis.eval(script, 1, "counter")  # Выполняется без race condition

Сравнение с другими

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

import redis
import time

r = redis.Redis()

# PostgreSQL запрос (медленно)
start = time.time()
user = db.query(User).filter_by(id=1).first()
print(f"PostgreSQL: {(time.time() - start)*1000:.2f}ms")
# Результат: 5-10ms

# Redis запрос (быстро)
start = time.time()
user = r.get("user:1")
print(f"Redis: {(time.time() - start)*1000000:.2f}мкс")
# Результат: 0.1-0.5мкс (в 10,000+ раз быстрее)

Когда Redis медленнее

• Если данные не помещаются в RAM (нужно использовать диск)
• Если нужны сложные запросы (JOIN, GROUP BY)
• Если нужна транзакционность с ACID
• Если много значений > 1MB

Архитектура типичной системы

Клиент → [Cache] Redis ← быстро
         ↓
       [Database] PostgreSQL ← надёжно, но медленнее

Redis как кэш перед БД:

• Отвечает на 90% запросов (быстро)
• 10% запросов идут в БД (медленнее, но реже)

Вывод

Redis быстро благодаря:

1. In-Memory хранилище (главный фактор)
2. Однопоточная архитектура с event loop
3. Оптимизированные структуры данных (O(1) операции)
4. Zero-copy где возможно
5. Простой протокол (RESP)
6. Написан на C без GC
7. Минимальный overhead на соединение

Результат: микросекундная задержка вместо миллисекунд — именно это делает Redis таким быстрым.