【Java】在高并发场景下，保证 Redis 缓存一致性的几种方案

在高并发场景下，保证 Redis 缓存一致性是一个常见的挑战。以下是几种常见的解决方案及其优缺点，以及相应的代码示例。

1. Cache Aside Pattern (旁路缓存模式)

原理

• 读取数据时，先读缓存，如果缓存没有命中，再从数据库读取，并将数据写入缓存。
• 更新数据时，先更新数据库，然后删除缓存。

优点

• 简单易实现，适用于读多写少的场景。
• 更新时立即删除缓存，能有效防止缓存数据不一致。

缺点

• 存在短暂的不一致性窗口期。
• 并发更新时可能导致缓存被频繁删除。

代码示例

public class CacheAsidePattern {
    private RedisTemplate<String, Object> redisTemplate;
    private DatabaseService databaseService;

    public CacheAsidePattern(RedisTemplate<String, Object> redisTemplate, DatabaseService databaseService) {
        this.redisTemplate = redisTemplate;
        this.databaseService = databaseService;
    }

    public Object get(String key) {
        Object value = redisTemplate.opsForValue().get(key);
        if (value == null) {
            synchronized (this) {
                value = redisTemplate.opsForValue().get(key);
                if (value == null) {
                    value = databaseService.getFromDb(key);
                    if (value != null) {
                        redisTemplate.opsForValue().set(key, value);
                    }
                }
            }
        }
        return value;
    }

    public void update(String key, Object value) {
        databaseService.updateDb(key, value);
        redisTemplate.delete(key);
    }
}

2. Read-Through Cache (读穿缓存)

原理

• 读取数据时，如果缓存未命中，由缓存系统从数据库加载数据，并将其缓存。

优点

• 自动加载数据到缓存，简化应用程序代码。
• 减少缓存未命中带来的性能损失。

缺点

• 实现复杂，需要自定义缓存加载逻辑。
• 写操作没有明确处理，需结合其他策略保证一致性。

代码示例

public class ReadThroughCache {
    private RedisTemplate<String, Object> redisTemplate;
    private DatabaseService databaseService;

    public ReadThroughCache(RedisTemplate<String, Object> redisTemplate, DatabaseService databaseService) {
        this.redisTemplate = redisTemplate;
        this.databaseService = databaseService;
    }

    public Object get(String key) {
        Object value = redisTemplate.opsForValue().get(key);
        if (value == null) {
            value = databaseService.getFromDb(key);
            if (value != null) {
                redisTemplate.opsForValue().set(key, value);
            }
        }
        return value;
    }
}

3. Write-Through Cache (写穿缓存)

原理

• 更新数据时，先更新缓存，再更新数据库。

优点

• 数据始终保持一致性，适合高一致性要求的场景。
• 简化读取逻辑，数据始终在缓存中。

缺点

• 写操作性能较低，因为每次写操作都涉及数据库更新。
• 如果数据库更新失败，缓存也会被污染。

代码示例

public class WriteThroughCache {
    private RedisTemplate<String, Object> redisTemplate;
    private DatabaseService databaseService;

    public WriteThroughCache(RedisTemplate<String, Object> redisTemplate, DatabaseService databaseService) {
        this.redisTemplate = redisTemplate;
        this.databaseService = databaseService;
    }

    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    public void update(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
        databaseService.updateDb(key, value);
    }
}

4. Write-Behind Cache (异步写缓存)

原理

• 更新数据时，先更新缓存，然后异步地将数据写入数据库。

优点

• 写操作性能较高，适用于写多读少的场景。
• 减少了直接写数据库的延迟。

缺点

• 实现复杂，需保证异步操作的可靠性。
• 存在数据丢失的风险，需要处理异步操作失败的情况。

代码示例

public class WriteBehindCache {
    private RedisTemplate<String, Object> redisTemplate;
    private DatabaseService databaseService;
    private ExecutorService executorService;

    public WriteBehindCache(RedisTemplate<String, Object> redisTemplate, DatabaseService databaseService) {
        this.redisTemplate = redisTemplate;
        this.databaseService = databaseService;
        this.executorService = Executors.newFixedThreadPool(10);
    }

    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    public void update(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
        executorService.submit(() -> {
            databaseService.updateDb(key, value);
        });
    }
}

5. Consistent Hashing (一致性哈希)

原理

• 通过一致性哈希算法，将缓存数据均匀分布到不同的缓存节点上。

优点

• 提高缓存的可扩展性和容错性。
• 数据分布均匀，减少单点压力。

缺点

• 实现复杂，需要引入一致性哈希算法。
• 适用于分布式缓存场景，对于单机缓存无显著优势。

代码示例

import java.util.SortedMap;
import java.util.TreeMap;

public class ConsistentHashing {
    private TreeMap<Integer, RedisTemplate<String, Object>> hashRing = new TreeMap<>();
    private int numberOfReplicas;

    public ConsistentHashing(int numberOfReplicas, List<RedisTemplate<String, Object>> redisTemplates) {
        this.numberOfReplicas = numberOfReplicas;
        for (RedisTemplate<String, Object> redisTemplate : redisTemplates) {
            addNode(redisTemplate);
        }
    }

    private void addNode(RedisTemplate<String, Object> node) {
        for (int i = 0; i < numberOfReplicas; i++) {
            int hash = hash(node.toString() + i);
            hashRing.put(hash, node);
        }
    }

    public RedisTemplate<String, Object> getNode(String key) {
        if (hashRing.isEmpty()) {
            return null;
        }
        int hash = hash(key);
        if (!hashRing.containsKey(hash)) {
            SortedMap<Integer, RedisTemplate<String, Object>> tailMap = hashRing.tailMap(hash);
            hash = tailMap.isEmpty() ? hashRing.firstKey() : tailMap.firstKey();
        }
        return hashRing.get(hash);
    }

    private int hash(String key) {
        return key.hashCode() & 0x7fffffff;
    }
}

每种策略都有其适用的场景和特点，具体选择哪种方案需要根据实际的业务需求和系统特性来决定。