Кэширование в Rust: Redis, Memcached и встроенные решения

Введение: Зачем кэширование в Rust?

Скорость — главное преимущество Rust. Но даже самый быстрый код может упереться в медленный ввод-вывод (I/O): запросы к базе данных, внешние API или вычисления сложных данных. Кэширование решает эту проблему, сохраняя результаты дорогих операций в быстром хранилище. Rust предлагает гибкие инструменты для кэширования: от простых встроенных структур данных до мощных распределенных систем, таких как Redis и Memcached.

В этой статье мы разберем все уровни кэширования в Rust: от простого HashMap до профессиональных решений с TTL (временем жизни) и синхронизацией. Вы узнаете, как выбрать подходящий инструмент для вашего проекта и избежать типичных ошибок.

1. Встроенное кэширование: HashMap и его вариации

Самый простой способ кэширования в Rust — использовать HashMap из стандартной библиотеки. Однако в многопоточной среде нужны дополнительные механизмы синхронизации.

1.1. Простой HashMap (однопоточный)

Для однопоточных приложений подходит обычный HashMap. Пример:

use std::collections::HashMap;

fn main() {
    let mut cache: HashMap<String, String> = HashMap::new();
    cache.insert("user:1".to_string(), "Alice".to_string());
    
    if let Some(name) = cache.get("user:1") {
        println!("Кэшированное значение: {}", name);
    }
}

Плюсы: минимальный код, нет зависимостей.
Минусы: нет TTL, не потокобезопасен, память не ограничена.

1.2. Потокобезопасный кэш с Mutex и Arc

Для многопоточных приложений используйте Arc<Mutex<HashMap>>:

use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::thread;

struct Cache {
    store: Arc<Mutex<HashMap<String, String>>>,
}

impl Cache {
    fn new() -> Self {
        Cache { store: Arc::new(Mutex::new(HashMap::new())) }
    }
    
    fn get(&self, key: &str) -> Option<String> {
        self.store.lock().ok()?.get(key).cloned()
    }
    
    fn set(&self, key: String, value: String) {
        self.store.lock().unwrap().insert(key, value);
    }
}

fn main() {
    let cache = Cache::new();
    let c1 = cache.clone();
    thread::spawn(move || {
        c1.set("key".to_string(), "value".to_string());
    });
    println!("{:?}", cache.get("key"));
}

Недостаток: блокировка Mutex может снизить производительность при высокой конкуренции.

1.3. Продвинутые библиотеки: lru и cached

Для production-кода лучше использовать готовые крейты:

• lru — реализует LRU (Least Recently Used) алгоритм вытеснения. Подходит для ограниченного кэша.
• cached — предоставляет макросы для автоматического кэширования функций с поддержкой TTL и LRU.

Пример с cached:

use cached::proc_macro::cached;

#[cached(size = 100, time = 300)]
fn expensive_computation(x: u32) -> u32 {
    std::thread::sleep(std::time::Duration::from_secs(2));
    x * x
}

fn main() {
    let result = expensive_computation(5); // выполняется 2 сек
    let cached_result = expensive_computation(5); // моментально
    println!("{}", cached_result);
}

2. Redis: распределенный кэш для масштабируемых систем

Redis — это in-memory хранилище данных, идеально подходящее для распределенного кэширования. В Rust для работы с Redis используется крейт redis.

2.1. Подключение и базовые операции

use redis::Commands;

fn main() -> redis::RedisResult<()> {
    let client = redis::Client::open("redis://127.0.0.1:6379/")?;
    let mut con = client.get_connection()?;
    
    // Установка значения с TTL (время жизни)
    con.set_ex("user:1", "Alice", 3600)?; // 1 час
    let value: String = con.get("user:1")?;
    println!("Из Redis: {}", value);
    
    Ok(())
}

2.2. Продвинутые возможности Redis

• Сериализация структур: используйте serde для хранения сложных данных.
• Pipeline и транзакции: для batch-операций.
• Pub/Sub: для уведомлений об инвалидации кэша.

Пример с сериализацией:

use serde::{Serialize, Deserialize};
use redis::Commands;

#[derive(Serialize, Deserialize, Debug)]
struct User {
    id: u32,
    name: String,
}

fn main() -> redis::RedisResult<()> {
    let client = redis::Client::open("redis://127.0.0.1:6379/")?;
    let mut con = client.get_connection()?;
    
    let user = User { id: 1, name: "Alice".into() };
    let serialized = serde_json::to_string(&user).unwrap();
    con.set_ex("user:1", serialized, 3600)?;
    
    let result: String = con.get("user:1")?;
    let deserialized: User = serde_json::from_str(&result).unwrap();
    println!("{:?}", deserialized);
    
    Ok(())
}

2.3. Когда выбирать Redis?

• Несколько экземпляров приложения (микросервисы).
• Необходимость в сложных структурах данных (списки, множества).
• Требуется постоянное хранение (RDB/AOF).

3. Memcached: легковесный и быстрый

Memcached — это еще один популярный распределенный кэш. Он проще Redis и не поддерживает сложные структуры данных, но зато быстрее и легче.

3.1. Работа с Memcached в Rust

Используем крейт memcache:

use memcache;

fn main() -> memcache::MemcacheResult<()> {
    let client = memcache::Client::new("memcache://127.0.0.1:11211")?;