Caching in C++: Redis, Memcached und eingebettete Lösungen – Fortgeschrittenes Niveau

Einleitung: Warum Caching für die C++-Leistung entscheidend ist

In der modernen hochlastigen C++-Entwicklung ist Caching keine Option mehr – es ist ein obligatorisches Architekturelement. Ohne es stößt jedes CRUD-System oder jeder Mikroservice schnell an die Grenzen der Datenbank, und die Latenz von Anfragen steigt exponentiell. Auf fortgeschrittener Ebene stehen wir vor einem Dilemma: Externe Systeme (Redis, Memcached) verwenden oder eine eigene In-Memory-Lösung in C++ entwickeln? In diesem Artikel analysieren wir die Vor- und Nachteile sowie konkrete Implementierungen jedes Ansatzes, basierend auf der praktischen Arbeit mit Netzwerkwarteschlangen, Sperren und Serialisierung.

1. Redis: Flexibilität und Datenstrukturen

Redis ist nicht nur ein einfacher Key-Value-Store. Sein Hauptvorteil ist der reichhaltige Satz an Datentypen: Strings, Hashes, Listen, Mengen, Sorted Sets. Für C++ gibt es mehrere Clients: redis-plus-plus (empfohlen) und hiredis (niedrige Ebene).

Beispiel für Verbindung und grundlegende Operationen mit redis-plus-plus

#include <sw/redis++/redis++.h>#include <iostream>

int main() {    // Verbindung zu Redis (Standard localhost:6379)    sw::redis::Redis redis("tcp://127.0.0.1:6379");

    // Setzen eines Werts mit TTL von 60 Sekunden    redis.set("user:1001", "John Doe", std::chrono::seconds(60));

    // Lesen    auto val = redis.get("user:1001");    if (val) {        std::cout << "User: " << *val << std::endl;    }

    // Arbeiten mit Hashes    redis.hset("session:abc", "token", "xyz123");    redis.hset("session:abc", "expires", "3600");    auto token = redis.hget("session:abc", "token");    std::cout << "Token: " << *token << std::endl;

    return 0;}

Fortgeschrittene Funktionen: Verwendung von Transaktionen über redis.multi() und redis.exec() sowie Pub/Sub für Cache-Invalidierungsbenachrichtigungen. Redis eignet sich hervorragend, wenn komplexe Strukturen mit atomaren Operationen (z. B. Inkrementieren eines Zählers) gespeichert werden müssen.

2. Memcached: Geschwindigkeit und Einfachheit

Memcached ist ein leichter, verteilter Cache, der für die Speicherung flacher Daten (Strings und binäre Blobs) optimiert ist. Es unterstützt keine Transaktionen oder komplexe Strukturen, punktet aber mit Geschwindigkeit und minimalem Speicherverbrauch. Für C++ verwenden wir die Bibliothek libmemcached.

Beispiel für die Arbeit mit Memcached über libmemcached

#include <libmemcached/memcached.h>#include <iostream>#include <cstring>

int main() {    memcached_st *memc = memcached_create(nullptr);    memcached_server_st *servers = nullptr;    memcached_return_t rc;

    // Server hinzufügen    servers = memcached_server_list_append(servers, "127.0.0.1", 11211, &rc);    rc = memcached_server_push(memc, servers);    if (rc != MEMCACHED_SUCCESS) {        std::cerr << "Fehler: " << memcached_strerror(memc, rc) << std::endl;        return 1;    }

    // Schreiben mit TTL von 30 Sekunden    const char *key = "config:db_host";    const char *value = "10.0.0.1";    rc = memcached_set(memc, key, strlen(key), value, strlen(value),                        std::time(0) + 30, (uint32_t)0);    if (rc != MEMCACHED_SUCCESS) {        std::cerr << "Set fehlgeschlagen: " << memcached_strerror(memc, rc) << std::endl;    }

    // Lesen    size_t val_len;    uint32_t flags;    char *retrieved = memcached_get(memc, key, strlen(key), &val_len, &flags, &rc);    if (rc == MEMCACHED_SUCCESS) {        std::cout << "DB Host: " << retrieved << std::endl;        free(retrieved);    }

    memcached_free(memc);    return 0;}

Wann Memcached wählen? Wenn Sie einen einfachen Cache für serialisierte Objekte benötigen, ohne komplexe Strukturen speichern zu müssen. Memcached ist ideal zum Caching von Ergebnissen von SQL-Abfragen oder HTML-Fragmenten.