Desafios Centrais da Consistência de Dados

Em cenários de alta concorrência, a sincronização entre o Redis, como camada de cache, e o banco de dados MySQL pode levar a inconsistências devido a:

• Ordem de escrita dupla: Atualizar primeiro o banco de dados ou o cache?
• Concorrência de leitura/escrita: Múltiplos threads operando simultaneamente no cache e banco de dados.
• Falhas em operações: Erros em etapas como a exclusão do cache, resultando em dados desatualiazdos residuais.

Estratégias de Resolução

1. Escrita Dupla com Exclusão Otimizada

Uma abordagem comum envolve atualizar o banco de dados MySQL primeiro e, em seguida, remover a entrada correspondente no cache Redis. Para mitigar riscos de falha na remoção, um mecanismo de compensação assíncrono pode ser integrado.

public void processarAtualizacao(Registro registro) {
    // Etapa 1: Persistir a alteração no banco de dados relacional
    sqlDatabase.atualizar(registro);
    // Etapa 2: Tentar invalidar a entrada de cache
    try {
        cacheRedis.excluirPorChave("registro:" + registro.getId());
    } catch (Exception e) {
        // Enviar tarefa para fila de mensagens para retentativa
        filaDeMensagens.enviar("tentativa_cache", registro.getId());
    }
}

Alternativamente, a exclusão do cache antes da atualização do banco de dados requer uma técnica como a "exclusão dupla atrasada" para minimizar a janela de inconsistência em ambientes concorrentes.

public void atualizarComExclusaoDupla(Item item) {
    cacheRedis.remover("item:" + item.getChave());
    sqlDatabase.modificar(item);
    // Aguardar um curto intervalo para permitir que leituras pendentes concluam
    Thread.sleep(500);
    cacheRedis.remover("item:" + item.getChave());
}

2. Sincronização via Binlog do MySQL

Para garantir a consistência final, o binlog do MySQL pode ser monitorado por ferramentas como o Debezium. As mudanças capturadas são publicadas em um broker (por exemplo, Apache Kafka) e consumidas por um serviço que atualiza ou remove as chaves no Redis de forma assíncrona.

Fluxo Típico: MySQL -> Binlog -> Debezium -> Kafka -> Serviço Consumidor -> Atualização do Redis.

Este método desacopla os sistemas, mas introduz complexidade operacional.

3. Expiração Automática de Cache

Configurar um tempo de vida (TTL) para as chaves no Redis atua como uma salvaguarda. Dados desatualizados serão eventualmente descartados, forçando uma recarga do banco de dados na próxima solicitação.

// Definir chave no cache com expiração de 20 minutos
cacheRedis.salvarComExpiracao("perfil_usuario:789", dadosPerfil, 1200);

Esta abordagem é simples, mas não adequada para aplicações que exigem consistência imediata.

Otimizações para Alta Concorrência

Controle com Locks Distribuídos

Para recursos críticos, um lock distribuído pode ser aplicado para serializar operações de leitura e escrita, garantindo a ordem correta.

public Dados recuperarDadosSeguros(String identificador) {
    Lock lock = distribuitedLockManager.obterLock("lock:" + identificador);
    lock.aquirir();
    try {
        Dados dados = cacheRedis.obter("dados:" + identificador);
        if (dados == null) {
            dados = sqlDatabase.consultar(identificador);
            cacheRedis.armazenar("dados:" + identificador, dados);
        }
        return dados;
    } finally {
        lock.liberar();
    }
}

Versionamento de Dados

Adicioanr um campo de versão ou timestamp no banco de dados permite validar se uma atualização é aplicável. A atualização só prosseguir se a versão no banco de dados coincidir com a esperada.

CREATE TABLE pedidos (
    id VARCHAR(36) PRIMARY KEY,
    descricao TEXT,
    versao INTEGER DEFAULT 1
);

public boolean tentarAtualizarPedido(Pedido pedidoAtualizado) {
    int linhasAfetadas = sqlDatabase.executarAtualizacao(
        "UPDATE pedidos SET descricao=?, versao=versao+1 WHERE id=? AND versao=?",
        pedidoAtualizado.getDescricao(), pedidoAtualizado.getId(), pedidoAtualizado.getVersao()
    );
    if (linhasAfetadas > 0) {
        cacheRedis.remover("pedido:" + pedidoAtualizado.getId());
        return true;
    }
    return false;
}

Tratamento de Exceções e Correção

Mecanismo de Retentativa Assíncrona

Falhas na operação de cache podem ser tratadas por filas de mensagens. Um consumidor retenta a exclusão periodicamente até o sucesso.

@Consumer(queue = "fila_retry")
public void processarRetentativa(String chave) {
    cacheRedis.excluirPorChave(chave);
}

Tarefas de Reconciliação Periódica

Um job agendado pode comparar dados no banco de dados e no cache, corrigindo discrepâncias encontradas.

@Scheduled(cron = "0 0 2 * * ?") // Executar diariamente às 2h
public void reconciliarDados() {
    List<item> itensBanco = sqlDatabase.listarTodos();
    for (Item item : itensBanco) {
        Item itemCache = cacheRedis.obter("item:" + item.getId());
        if (!item.equals(itemCache)) {
            cacheRedis.atualizar("item:" + item.getId(), item);
        }
    }
}</item>

Comparação e Recomendações

A escolha depende do equilíbrio entre a necessidade de consistência imediata e o impacto no desempenho e complexidade do sistema.