Mise en cache en C++ : Redis, Memcached et solutions intégrées

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction : Pourquoi mettre en cache en C++ ?

Dans le développement moderne en C++, la vitesse d'exécution d'une application est souvent un facteur critique. La mise en cache permet de réduire considérablement le temps d'accès aux données, de diminuer la charge sur les bases de données et d'accélérer l'exécution d'opérations de calcul répétitives. Dans cet article, nous allons examiner en détail trois approches principales de la mise en cache en C++ : l'utilisation de systèmes externes (Redis et Memcached) et les solutions intégrées disponibles "prêtes à l'emploi".

Que vous développiez un serveur web à forte charge, un moteur de jeu ou un système financier, le choix correct d'une stratégie de mise en cache peut améliorer les performances de plusieurs dizaines de fois. Nous analyserons les avantages et les inconvénients de chaque approche, et fournirons des exemples de code prêts à l'emploi pour une intégration rapide.

1. Solutions intégrées pour la mise en cache en C++

Avant de connecter des services externes, il convient d'examiner les possibilités offertes par le langage C++ lui-même et sa bibliothèque standard. Les solutions intégrées sont idéales pour les applications monothread ou lorsque les données ne doivent pas être partagées entre plusieurs processus.

1.1. Cache LRU simple basé sur `std::unordered_map`

L'algorithme LRU (Least Recently Used) est l'un des plus populaires pour la mise en cache intégrée. Il supprime automatiquement les éléments les moins utilisés lorsque le cache atteint sa limite de mémoire.

#include <unordered_map>#include <list>#include <mutex>

template <typename Key, typename Value>class LRUCache {private:    size_t capacity_;    std::list<Key> items_;    std::unordered_map<Key, std::pair<Value, typename std::list<Key>::iterator>> cache_;    std::mutex mutex_;

public:    LRUCache(size_t capacity) : capacity_(capacity) {}

    void put(const Key& key, const Value& value) {        std::lock_guard<std::mutex> lock(mutex_);        auto it = cache_.find(key);        if (it != cache_.end()) {            items_.erase(it->second.second);            cache_.erase(it);        }        items_.push_front(key);        cache_[key] = {value, items_.begin()};                if (cache_.size() > capacity_) {            auto last = items_.back();            items_.pop_back();            cache_.erase(last);        }    }

    std::optional<Value> get(const Key& key) {        std::lock_guard<std::mutex> lock(mutex_);        auto it = cache_.find(key);        if (it == cache_.end()) return std::nullopt;                // Déplace la clé au début de la liste        items_.splice(items_.begin(), items_, it->second.second);        return it->second.first;    }};

Avantages : frais généraux minimaux, pas de latence réseau, contrôle total sur les données.

Inconvénients : les données ne sont pas partagées entre les threads (synchronisation manuelle requise), limitées par la mémoire d'un seul processus.

1.2. Utilisation de `std::shared_mutex` pour le multithreading

Pour les applications multithread, on peut améliorer les performances en utilisant shared_mutex, qui permet la lecture simultanée par plusieurs threads :

#include <shared_mutex>

class ThreadSafeCache {    std::map<std::string, std::string> data_;    mutable std::shared_mutex mutex_;    public:    std::string read(const std::string& key) {        std::shared_lock lock(mutex_);        auto it = data_.find(key);        return (it != data_.end()) ? it->second : "";    }        void write(const std::string& key, const std::string& value) {        std::unique_lock lock(mutex_);        data_[key] = value;    }};