java-redis-击穿

Java 与 Redis 之缓存击穿问题解决方案

1. 背景:缓存的基本概念

在高并发系统中,缓存是一个非常重要的优化手段。它的基本思想是将热点数据缓存在高速的存储系统(如 Redis、Memcached)中,从而减轻数据库等持久层的压力,并加快请求响应速度。

常见的缓存模式有:

  • 缓存读写:读取数据时优先从缓存中获取,如果缓存中没有数据,则从数据库或其他持久化存储中获取并缓存。
  • 缓存失效策略:缓存系统通常会为每条缓存设置过期时间(TTL),过期后数据会从缓存中删除,避免数据长期过期。
2. 缓存击穿的概念

缓存击穿(Cache Breakdown)是指缓存中某些高并发访问的数据在失效的瞬间,大量请求同时穿透缓存直接访问数据库的情况。由于这些数据是热点数据,短时间内大量请求集中访问数据库,容易导致数据库过载,甚至宕机。

缓存击穿的触发场景通常是:

  • 缓存数据有明确的过期时间(TTL)。
  • 热点数据在缓存失效后,瞬间有大量请求同时发起读取操作。

区别于其他缓存问题

  • 缓存穿透:请求的数据在数据库中不存在,直接穿透缓存,访问数据库。
  • 缓存雪崩:大量缓存同时失效,导致大量请求直接访问数据库,可能引发雪崩效应。
3. 缓存击穿的解决方案

为了避免缓存击穿问题,我们需要在缓存失效时控制多个并发请求直接访问数据库的情况。常用的解决方案包括:

  1. 互斥锁:为某个热点数据设置一个锁,当第一个请求获取数据时,其他请求等待,数据更新后释放锁。
  2. 缓存预热:在数据过期之前,提前主动刷新缓存,避免数据过期导致的瞬时压力。
  3. 逻辑过期:缓存中的数据设置逻辑过期标志,定期异步更新数据,避免高并发下的缓存失效。
  4. 过期自动更新:使用定时任务,在缓存失效前重新加载数据,确保缓存中的数据始终有效。
4. 方案一:互斥锁解决缓存击穿

**互斥锁(Mutex)**是解决缓存击穿最常见的办法。当某个缓存失效时,第一个请求负责加载数据并重新设置缓存,其他请求等待数据加载完成后直接返回缓存结果。

4.1. 基本流程
  1. 请求到达,尝试读取缓存。
  2. 如果缓存中有数据,直接返回。
  3. 如果缓存没有数据,使用互斥锁保证只有一个线程能够从数据库获取数据,其他请求等待。
  4. 获取到数据的线程更新缓存,并释放锁。
  5. 其他请求重新读取缓存。
4.2. 代码实现

下面是一个基于 Redis 实现互斥锁的缓存击穿解决方案。我们使用 Java 的 Redis 客户端(Jedis)来进行 Redis 操作,并利用 Redis 的 SETNX(set if not exists)来实现分布式锁。

import redis.clients.jedis.Jedis;

public class CacheService {

    private Jedis jedis;

    public CacheService(Jedis jedis) {
        this.jedis = jedis;
    }

    // 获取数据的方法,包含缓存逻辑
    public String getData(String key) {
        // 尝试从 Redis 缓存中获取数据
        String value = jedis.get(key);
        
        if (value == null) {
            // 缓存中没有数据,进入加载流程
            String lockKey = "lock:" + key;
            
            // 尝试加锁,避免缓存击穿
            if (tryLock(lockKey)) {
                try {
                    // 模拟从数据库加载数据
                    value = loadFromDB(key);
                    
                    // 将数据写入缓存,并设置超时时间
                    jedis.setex(key, 300, value);
                } finally {
                    // 释放锁
                    releaseLock(lockKey);
                }
            } else {
                // 获取锁失败,等待其他线程更新缓存
                try {
                    // 等待一段时间再尝试获取缓存
                    Thread.sleep(100);
                    return jedis.get(key);  // 再次从缓存获取
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
        return value;
    }

    // 尝试获取锁
    private boolean tryLock(String lockKey) {
        // 使用 Redis 的 SETNX 设置锁,成功返回1,失败返回0
        String result = jedis.set(lockKey, "1", "NX", "EX", 10); // 锁过期时间为10秒
        return "OK".equals(result);
    }

    // 释放锁
    private void releaseLock(String lockKey) {
        jedis.del(lockKey);  // 删除锁
    }

    // 模拟从数据库加载数据
    private String loadFromDB(String key) {
        System.out.println("Loading data from DB for key: " + key);
        return "DBValueFor" + key;
    }
}
4.3. 互斥锁的优点和缺点
  • 优点
      - 简单有效,确保在缓存失效时只有一个请求访问数据库,避免并发访问造成的数据库压力。
  • 缺点
      - 可能会出现锁等待时间过长的问题,特别是在加载数据耗时较多的场景中,其他请求需要等待锁释放。
5. 方案二:逻辑过期解决缓存击穿

逻辑过期是一种延长缓存有效期的方式。我们并不真正删除缓存,而是将缓存数据设置为逻辑过期状态。每次读取缓存时,仍然返回数据,但异步刷新缓存中的数据。

5.1. 基本流程
  1. 请求到达,读取缓存中的数据。
  2. 如果缓存中的数据未过期,直接返回。
  3. 如果缓存数据过期,异步从数据库更新缓存,但仍返回旧的缓存数据给当前请求。
5.2. 代码实现
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class LogicalExpireCacheService {

    private Jedis jedis;
    private ExecutorService executorService = Executors.newFixedThreadPool(10);

    public LogicalExpireCacheService(Jedis jedis) {
        this.jedis = jedis;
    }

    // 获取数据的方法,包含逻辑过期处理
    public String getData(String key) {
        // 尝试从 Redis 缓存中获取数据
        String cacheData = jedis.get(key);
        
        if (cacheData != null && !isExpired(cacheData)) {
            return cacheData;  // 如果缓存未过期,直接返回
        }

        // 如果缓存过期,异步更新缓存
        executorService.submit(() -> {
            String newValue = loadFromDB(key);
            jedis.set(key, newValue);
        });

        // 返回旧数据,避免直接击穿数据库
        return cacheData;
    }

    // 检查缓存数据是否过期(模拟逻辑过期)
    private boolean isExpired(String cacheData) {
        // 解析数据的过期标志,这里可以自定义逻辑
        return false;  // 简化示例,不真正实现
    }

    // 模拟从数据库加载数据
    private String loadFromDB(String key) {
        System.out.println("Loading data from DB for key: " + key);
        return "NewDBValueFor" + key;
    }
}
5.3. 逻辑过期的优点和缺点
  • 优点
      - 不会阻塞用户请求,哪怕缓存过期,用户仍能拿到旧的数据。
      - 适合对时效性要求不高的场景。

  • 缺点
      - 异步更新缓存的过程存在时间差,可能导致部分用户获取的是旧数据。
      - 数据一致性要求较高时需要谨慎使用。

6. 方案三:缓存预热

缓存预热指的是在缓存数据即将失效之前,主动更新缓存数据,避免缓存过期瞬间的大量并发请求击穿缓存。

6.1. 基本流程
  1. 定期提前刷新缓存,在缓存过期前将新数据写入缓存。
  2. 使用定时任务或后台线程进行缓存的预加载和刷新,确保热点数据始终在缓存中。
6.2. 实现方式

通过 Spring 的定时任务机制或其他调度工具,定期刷新热点数据的缓存。例如:

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

@Service
public class CachePreheatService {

    private Jedis jedis;

    public CachePreheatService(Jedis jedis) {
        this.jedis = jedis;
    }

    // 定时任务,每隔 5 分钟刷新缓存
    @Scheduled(fixedRate = 300000)
    public void

 refreshCache() {
        String key = "hotDataKey";
        String value = loadFromDB(key);
        jedis.set(key, value);
        System.out.println("Cache refreshed for key: " + key);
    }

    // 模拟从数据库加载数据
    private String loadFromDB(String key) {
        System.out.println("Loading data from DB for key: " + key);
        return "PreheatedDBValueFor" + key;
    }
}
6.3. 优点和缺点
  • 优点
      - 通过提前刷新缓存,避免缓存失效时的大量并发请求,确保热点数据始终存在缓存中。
  • 缺点
      - 需要额外的调度管理和计算热点数据,不能解决所有场景下的缓存击穿问题。
7. 总结

缓存击穿是高并发系统中一个常见且重要的问题。针对不同的业务场景,我们可以采取多种措施来应对缓存击穿,如互斥锁、逻辑过期、缓存预热等。

  • 互斥锁:确保缓存失效时只有一个线程能够访问数据库,适合数据一致性要求较高的场景。
  • 逻辑过期:返回旧缓存数据并异步更新缓存,适合对时效性要求不高的场景。
  • 缓存预热:提前刷新缓存,避免热点数据在缓存失效时被大量请求穿透。

这些策略可以结合使用,根据不同的业务场景和性能要求,选择最合适的方案,确保系统在高并发场景下的稳定性。

你可能感兴趣的:(java,redis,spring,boot)