Cache em C++: Redis e outros

Cache em C++: Redis e outras ferramentas populares

Em aplicações C++ de alta carga, a velocidade de acesso aos dados é crítica. O cache permite reduzir o tempo de resposta do servidor em 10 a 100 vezes, diminuindo a carga em bancos de dados e APIs externas. Neste artigo, analisaremos as principais bibliotecas para trabalhar com cache em C++: desde o clássico Redis até os mecanismos embutidos LevelDB e RocksDB.

1. Redis e bibliotecas cliente para C++

Redis é o armazenamento in-memory key-value mais popular, suportando estruturas de dados complexas (listas, conjuntos, hashes). Para C++, existem dois clientes principais:

hiredis — uma biblioteca C minimalista (oficial), facilmente integrável em C++ através de wrappers.
redis-plus-plus — uma biblioteca moderna C++17 com cobertura completa dos comandos Redis, suporte a pool de conexões, pipeline e transações.

Exemplo com hiredis (síncrono)

#include <hiredis/hiredis.h>#include <iostream>

int main() {    redisContext *c = redisConnect("127.0.0.1", 6379);    if (c == nullptr || c->err) {        std::cerr << "Connection error: " << c->errstr << std::endl;        return 1;    }

    redisReply *reply = (redisReply*)redisCommand(c, "SET key hello");    freeReplyObject(reply);

    reply = (redisReply*)redisCommand(c, "GET key");    if (reply->type == REDIS_REPLY_STRING) {        std::cout << "GET key: " << reply->str << std::endl;    }    freeReplyObject(reply);    redisFree(c);    return 0;}

Exemplo com redis-plus-plus (assíncrono + pool)

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

int main() {    sw::redis::Redis redis("tcp://127.0.0.1:6379");

    // Configuração com TTL (5 segundos)    redis.setex("user:42", 5, "John Doe");

    // Obtenção    auto val = redis.get("user:42");    if (val) {        std::cout << "Cached user: " << *val << std::endl;    } else {        std::cout << "Key expired or not found" << std::endl;    }    return 0;}

Vantagens do Redis: alta velocidade (microssegundos), conjunto rico de comandos, replicação, clusterização. Desvantagens: consome memória RAM, requer um servidor separado.

2. Memcached e libmemcached

Memcached é o cache distribuído mais simples, armazenando dados apenas na memória RAM. Para C++, utiliza-se a biblioteca libmemcached (ou seu wrapper C++ libmemcachedutil).

Exemplo com libmemcached

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

int main() {    memcached_st *memc = memcached_create(nullptr);    memcached_server_add(memc, "127.0.0.1", 11211);

    const char *key = "session_token";    const char *value = "abc123";    memcached_return_t rc = memcached_set(memc, key, strlen(key),                                          value, strlen(value),                                          0, 0); // 0 - sem compressão, 0 - TTL

    if (rc == MEMCACHED_SUCCESS) {        size_t value_length;        uint32_t flags;        char *result = memcached_get(memc, key, strlen(key),                                     &value_length, &flags, &rc);        if (rc == MEMCACHED_SUCCESS) {            std::cout << "Get: " << result << std::endl;            free(result);        }    }    memcached_free(memc);    return 0;}

Quando escolher Memcached: se precisar de cache simples sem estruturas de dados complexas, e a máxima performance for importante. O Redis ganha em funcionalidade, o Memcached em simplicidade.