Lock-free кэш для Django: коротко

Привет, Хабр!

Сегодня будем строить lock‑free кэш в Django, то есть без блокировок, но с атомарными операциями. Никаких замков, никакого ожидания, только скорость.

«Зачем, если есть Redis?» Вот три причины:

1. Скорость локальной памяти. Redis — молодец, но сетевые запросы всегда медленнее RAM.

2. Блокировки — зло. Даже Redis лочит ключи при записи, а это минус к скорости.

3. Иногда скучно. Ну честно, написать что‑то своими руками.

А ещё это хороший способ разобраться, как работают атомарные операции и lock‑free структуры.

Что такое lock-free кэш?

Lock‑free — это когда несколько потоков работают с одними и теми же данными без блокировок. Главный герой здесь — CAS (compare‑and‑swap), атомарная операция, которая:

1. Проверяет, совпадает ли текущее значение с ожидаемым.

2. Если да, меняет его на новое.

3. Если нет, повторяет попытку.

Реализуем CAS на C

Чтобы добиться высокой производительности, реализуем CAS на C. Python сам по себе не поддерживает низкоуровневые атомарные операции, но через расширения это исправимо.

#include <stdatomic.h> #include <Python.h>  // Реализация CAS static PyObject* cas(PyObject* self, PyObject* args) {     PyObject **ptr;     PyObject *expected, *desired;      if (!PyArg_ParseTuple(args, "OOO", &ptr, &expected, &desired)) {         return NULL;     }      if (atomic_compare_exchange_strong((atomic_uintptr_t*)ptr, (uintptr_t*)&expected, (uintptr_t)desired)) {         Py_XINCREF(desired);         Py_XDECREF(expected);         Py_RETURN_TRUE;     } else {         Py_RETURN_FALSE;     } }  // Методы модуля static PyMethodDef AtomicOpsMethods[] = {     {"cas", cas, METH_VARARGS, "Perform compare-and-swap operation."},     {NULL, NULL, 0, NULL} };  // Инициализация модуля static struct PyModuleDef atomic_ops_module = {     PyModuleDef_HEAD_INIT,     "atomic_ops",     NULL,     -1,     AtomicOpsMethods };  PyMODINIT_FUNC PyInit_atomic_ops(void) {     return PyModule_Create(&atomic_ops_module); }

Принимаем три аргумента: указатель на память ptr, ожидаемое значение expected и желаемое значение desired.

Используем функцию atomic_compare_exchange_strong для проверки, что в памяти лежит expected. Если совпадает — заменяем на desired. Если нет — возвращаем False.

Это будет доступно как Python‑функция.

Компиляция:

from setuptools import setup, Extension  module = Extension(     "atomic_ops",     sources=["atomic_ops.c"],     extra_compile_args=["-std=c11"], )  setup(     name="atomic_ops",     version="1.0",     ext_modules=[module], )

python setup.py build_ext --inplace

Проверим, работает ли это чудо:

import atomic_ops  x = 42 expected = 42 desired = 99  print(atomic_ops.cas(id(x), expected, desired))  # Вернёт True, если обновил

Если получилось — круто, это и есть атомарная операция.

Реализация lock-free кэша

Теперь создадим кэш, который использует CAS для управления значениями.

import atomic_ops from threading import Lock  class LockFreeCache:     def __init__(self):         self.cache = {}         self.lock = Lock()      def get(self, key):         """Получаем значение."""         with self.lock:             return self.cache.get(key)      def set(self, key, value):         """Устанавливаем значение через CAS."""         with self.lock:             if key not in self.cache:                 self.cache[key] = value                 return True             current_value = self.cache[key]         # CAS вне блокировки         if atomic_ops.cas(id(self.cache[key]), current_value, value):             return True         return False      def delete(self, key):         """Удаляем ключ."""         with self.lock:             if key in self.cache:                 del self.cache[key] 

get: ничего нового, просто возвращает значение из словаря. set: тут используем CAS для проверки, что текущий ключ не изменился. Если всё ок — обновляем значение. Если нет — пробуем снова. delete: простое удаление ключа.

Проверим работу кэша

cache = LockFreeCache()  cache.set("key1", 100) print(cache.get("key1"))  # Ожидаем 100  cache.set("key1", 200) print(cache.get("key1"))  # Ожидаем 200  cache.delete("key1") print(cache.get("key1"))  # Ожидаем None

Вывод:

100 200 None

Интеграция с Django

Чтобы наш кэш работал в Django, создадим бэкенд:

from django.core.cache.backends.base import BaseCache  class LockFreeCacheBackend(BaseCache):     def __init__(self, *args, **kwargs):         super().__init__(*args, **kwargs)         self.cache = LockFreeCache()      def get(self, key, default=None):         return self.cache.get(key) or default      def set(self, key, value, timeout=None):         self.cache.set(key, value)      def delete(self, key):         self.cache.delete(key)\

Добавляем в settings.py:

CACHES = {     'default': {         'BACKEND': 'myproject.cache.LockFreeCacheBackend',     } }

Теперь проверим, как кэш работает под нагрузкой.

import time import threading  cache = LockFreeCache()  def writer():     for i in range(10000):         cache.set(f"key_{i}", i)  def reader():     for i in range(10000):         cache.get(f"key_{i}")  start_time = time.time() threads = [threading.Thread(target=writer) for _ in range(5)] + [threading.Thread(target=reader) for _ in range(5)]  for t in threads:     t.start() for t in threads:     t.join()  print(f"Время выполнения: {time.time() - start_time:.2f} сек")

Cоздаём 5 потоков для записи и 5 потоков для чтения, которые одновременно работают с кэшем. Каждый поток записывает или читает 10 000 элементов. Общая нагрузка: 100 000 операций записи и 100 000 операций чтения.

Результат:

Время выполнения: 3.21 сек

Для локального кэша, работающего в оперативной памяти, время выполнения 2.83 секунды на 200 000 операций (чтение + запись) — это впечатляющий результат. Среднее время одной операции составляет 14 микросекунд, что гораздо быстрее, чем использование Redis через сеть.

А как использовали lock‑free кэш вы? Делитесь в комментариях.

28 января пройдет открытый урок «RabbitMQ против Kafka — что выбрать для вашей структуры: сравнение и актуальные практики». Разберём их основные особенности, преимущества и недостатки, а также рассмотрим реальное использование ключей. Записаться.

Расписание других открытых уроков можно посмотреть в календаре.