微服务架构中因缓存击穿导致数据库压力倍增的性能治理方法 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

微服务架构下缓存击穿的性能治理：一场技术攻坚战

各位同学，大家好！今天我们聚焦一个微服务架构中常见的性能瓶颈：缓存击穿。相信大家在实际工作中或多或少都遇到过类似的问题，当缓存中不存在的数据被大量并发请求同时访问时，这些请求会直接穿透缓存层，直击数据库，导致数据库压力骤增，甚至崩溃。

本次讲座，我们将深入探讨缓存击穿的成因、危害，并提供一系列行之有效的治理方案，包含代码示例和逻辑分析，帮助大家在实际项目中避免和解决此类问题。

缓存击穿：隐形的性能杀手

什么是缓存击穿？

缓存击穿是指当缓存中不存在某个key对应的数据时（通常是由于缓存过期或从未缓存），大量的并发请求同时请求这个不存在的key，导致这些请求直接穿透缓存，全部落到数据库上。数据库无法承受如此高的并发压力，从而导致性能下降，甚至崩溃。

缓存击穿的危害

数据库压力倍增: 大量请求直接访问数据库，导致数据库负载急剧增加，影响其他业务的正常运行。
系统响应时间延长: 数据库处理能力有限，大量请求排队等待，导致系统整体响应时间延长，用户体验下降。
服务雪崩: 如果数据库崩溃，依赖于数据库的服务也会受到影响，最终可能导致整个系统崩溃，形成服务雪崩。

缓存击穿与缓存穿透的区别

特性	缓存击穿	缓存穿透
key是否存在	key存在于数据库，但缓存中不存在（过期或未缓存）	key既不存在于缓存，也不存在于数据库中
请求目标	相同的 key	不同的 key (通常是恶意攻击)
应对策略	缓存预热、互斥锁、永不过期	参数校验、布隆过滤器

缓存击穿的治理方案

针对缓存击穿问题，我们可以采取多种策略来解决，下面我们详细介绍几种常用的方案：

1. 互斥锁 (Mutex Lock)

互斥锁是最简单有效的解决方案。当一个请求发现缓存中不存在目标数据时，先尝试获取一个互斥锁。如果获取成功，则从数据库加载数据，并将其写入缓存，然后释放锁。其他请求在等待锁的过程中会被阻塞，直到第一个请求完成数据加载和缓存写入。

代码示例 (Java + Redis)

import redis.clients.jedis.Jedis;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class CacheService {

    private static final String CACHE_PREFIX = "data:";
    private static final String LOCK_PREFIX = "lock:";
    private final Jedis jedis;
    private final Lock lock = new ReentrantLock();

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

    public String getData(String key) {
        String cacheKey = CACHE_PREFIX + key;
        String lockKey = LOCK_PREFIX + key;

        String data = jedis.get(cacheKey);
        if (data != null) {
            return data;
        }

        // 尝试获取锁
        if (lock.tryLock()) {
            try {
                // 双重检查，避免多个线程同时获取锁
                data = jedis.get(cacheKey);
                if (data != null) {
                    return data;
                }

                // 从数据库加载数据
                data = loadDataFromDatabase(key);

                // 将数据写入缓存
                if (data != null) {
                    jedis.setex(cacheKey, 60, data); // 设置过期时间为 60 秒
                }

                return data;

            } finally {
                lock.unlock();
            }
        } else {
            // 获取锁失败，等待一段时间后重试
            try {
                TimeUnit.MILLISECONDS.sleep(50);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return getData(key); // 递归调用，重试
        }
    }

    private String loadDataFromDatabase(String key) {
        // 模拟从数据库加载数据
        System.out.println("Loading data from database for key: " + key);
        try {
            TimeUnit.SECONDS.sleep(1); // 模拟数据库查询耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        if ("testKey".equals(key)) {
            return "Data from database for testKey";
        }
        return null;
    }

    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        CacheService cacheService = new CacheService(jedis);

        // 模拟并发请求
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                String data = cacheService.getData("testKey");
                System.out.println(Thread.currentThread().getName() + " - Data: " + data);
            }).start();
        }

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        jedis.close();
    }
}

代码解释:

CACHE_PREFIX 和 LOCK_PREFIX 定义了缓存 Key 和锁 Key 的前缀，避免命名冲突。
getData(String key) 方法首先尝试从缓存中获取数据。
如果缓存未命中，则尝试获取互斥锁 (lock.tryLock())。
如果获取锁成功，则再次检查缓存 (双重检查)，避免多个线程同时获取锁并加载数据。
从数据库加载数据 (loadDataFromDatabase(key))，并将数据写入缓存 (jedis.setex(cacheKey, 60, data))。
如果获取锁失败，则等待一段时间后重试 (getData(key))。
loadDataFromDatabase(String key) 方法模拟从数据库加载数据，实际项目中需要替换为真实的数据访问逻辑。
main 方法模拟并发请求，验证互斥锁的有效性。

互斥锁的优点：

简单易懂，易于实现。
能够有效防止缓存击穿。

互斥锁的缺点：

性能较低，因为等待锁的请求会被阻塞。
可能导致死锁，需要注意锁的释放。

改进：使用分布式锁

在微服务架构中，通常需要使用分布式锁来保证多个服务实例之间的互斥性。可以使用 Redis 的 SETNX 命令实现分布式锁。

2. 永不过期 (Never Expire)

将热点数据设置为永不过期，可以避免缓存过期导致的缓存击穿。但是，这种方案需要保证数据的一致性，当数据库中的数据发生变化时，需要及时更新缓存。

代码示例 (Java + Redis)

import redis.clients.jedis.Jedis;

import java.util.concurrent.TimeUnit;

public class CacheService {

    private static final String CACHE_PREFIX = "data:";
    private final Jedis jedis;

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

    public String getData(String key) {
        String cacheKey = CACHE_PREFIX + key;

        String data = jedis.get(cacheKey);
        if (data != null) {
            return data;
        }

        // 从数据库加载数据
        data = loadDataFromDatabase(key);

        // 将数据写入缓存 (永不过期)
        if (data != null) {
            jedis.set(cacheKey, data); // 不设置过期时间
        }

        return data;
    }

    public void updateData(String key, String newData) {
        String cacheKey = CACHE_PREFIX + key;
        // 更新数据库
        updateDataInDatabase(key, newData);
        // 更新缓存
        jedis.set(cacheKey, newData);
    }

    private String loadDataFromDatabase(String key) {
        // 模拟从数据库加载数据
        System.out.println("Loading data from database for key: " + key);
        try {
            TimeUnit.SECONDS.sleep(1); // 模拟数据库查询耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        if ("testKey".equals(key)) {
            return "Data from database for testKey";
        }
        return null;
    }

    private void updateDataInDatabase(String key, String newData){
        //模拟更新数据库
        System.out.println("Updating data in database for key: " + key + " with new Data: " + newData);
        try {
            TimeUnit.SECONDS.sleep(1); // 模拟数据库更新耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        CacheService cacheService = new CacheService(jedis);

        // 首次加载数据
        String data = cacheService.getData("testKey");
        System.out.println("Data: " + data);

        // 模拟更新数据
        cacheService.updateData("testKey", "New data from database");

        // 再次获取数据
        data = cacheService.getData("testKey");
        System.out.println("Data: " + data);

        jedis.close();
    }
}

代码解释:

getData(String key) 方法中，使用 jedis.set(cacheKey, data) 将数据写入缓存，不设置过期时间。
updateData(String key, String newData) 方法用于更新数据，需要同时更新数据库和缓存。

永不过期的优点：

能够有效防止缓存击穿。
性能较高，因为不需要频繁地从数据库加载数据。

永不过期的缺点：

需要保证数据的一致性，实现较为复杂。
会占用较多的缓存空间。

3. 提前更新 (Cache Preheating)

在系统启动时，或者在数据更新后，主动将热点数据加载到缓存中，可以避免缓存击穿。这种方案适用于数据更新频率较低的场景。

代码示例 (Java)

import redis.clients.jedis.Jedis;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class CachePreheater {

    private final Jedis jedis;
    private final List<String> hotKeys;

    public CachePreheater(Jedis jedis) {
        this.jedis = jedis;
        this.hotKeys = new ArrayList<>();
        // 初始化热点Key列表
        hotKeys.add("product1");
        hotKeys.add("product2");
        hotKeys.add("product3");
    }

    public void preheatCache() {
        System.out.println("Preheating cache...");
        for (String key : hotKeys) {
            loadDataAndCache(key);
        }
        System.out.println("Cache preheating completed.");
    }

    private void loadDataAndCache(String key) {
        // 从数据库加载数据
        String data = loadDataFromDatabase(key);
        // 将数据写入缓存
        if (data != null) {
            jedis.setex("product:" + key, 3600, data); // 设置过期时间为 1 小时
            System.out.println("Cached key: " + key + " with data: " + data);
        } else {
            System.out.println("No data found in database for key: " + key);
        }
    }

    private String loadDataFromDatabase(String key) {
        // 模拟从数据库加载数据
        try {
            TimeUnit.MILLISECONDS.sleep(500); // 模拟数据库查询耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        if ("product1".equals(key)) {
            return "Product 1 Details";
        } else if ("product2".equals(key)) {
            return "Product 2 Details";
        } else if ("product3".equals(key)) {
            return "Product 3 Details";
        }
        return null;
    }

    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        CachePreheater preheater = new CachePreheater(jedis);
        preheater.preheatCache();
        jedis.close();
    }
}

代码解释:

CachePreheater 类负责缓存预热。
hotKeys 列表存储需要预热的热点 Key。
preheatCache() 方法遍历 hotKeys 列表，加载数据并写入缓存。
loadDataAndCache() 方法从数据库加载数据，并将数据写入缓存。
loadDataFromDatabase() 方法模拟从数据库加载数据。
main 方法创建 CachePreheater 实例，并执行缓存预热。

提前更新的优点：

能够有效防止缓存击穿。
可以提高系统的响应速度。

提前更新的缺点：

需要提前预测热点数据。
如果热点数据发生变化，需要及时更新缓存。

4. 使用Null值占位

当数据库查询结果为空时，仍然将一个NULL值(或其他特殊标记)写到缓存中，设置一个较短的过期时间，防止大量请求穿透到数据库。

代码示例 (Java + Redis)

import redis.clients.jedis.Jedis;

import java.util.concurrent.TimeUnit;

public class CacheService {

    private static final String CACHE_PREFIX = "data:";
    private static final String NULL_VALUE = "NULL";
    private final Jedis jedis;

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

    public String getData(String key) {
        String cacheKey = CACHE_PREFIX + key;

        String data = jedis.get(cacheKey);
        if (data != null) {
            if (NULL_VALUE.equals(data)) {
                return null; // 返回 null 表示数据不存在
            }
            return data;
        }

        // 从数据库加载数据
        data = loadDataFromDatabase(key);

        // 将数据写入缓存
        if (data != null) {
            jedis.setex(cacheKey, 60, data); // 设置过期时间为 60 秒
        } else {
            jedis.setex(cacheKey, 60, NULL_VALUE); // 缓存 NULL 值
        }

        return data;
    }

    private String loadDataFromDatabase(String key) {
        // 模拟从数据库加载数据
        System.out.println("Loading data from database for key: " + key);
        try {
            TimeUnit.SECONDS.sleep(1); // 模拟数据库查询耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        // 假设 key "nonExistentKey" 在数据库中不存在
        if ("testKey".equals(key)) {
            return "Data from database for testKey";
        }
        return null;
    }

    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        CacheService cacheService = new CacheService(jedis);

        // 尝试获取一个不存在的 key
        String data = cacheService.getData("nonExistentKey");
        System.out.println("Data for nonExistentKey: " + data); // 输出 null

        // 再次尝试获取同一个不存在的 key (会从缓存中获取 NULL 值)
        data = cacheService.getData("nonExistentKey");
        System.out.println("Data for nonExistentKey: " + data); // 输出 null

        jedis.close();
    }
}

代码解释:

NULL_VALUE 定义了用于表示 NULL 值的字符串。
getData(String key) 方法中，如果从缓存中获取到 NULL_VALUE，则返回 null。
如果从数据库加载数据为空，则将 NULL_VALUE 写入缓存。

使用Null值占位的优点：

可以避免缓存穿透。
实现简单。

使用Null值占位的缺点：

需要占用额外的缓存空间。
需要处理 NULL 值带来的逻辑复杂性。

5. 异步更新 (Asynchronous Refresh)

使用消息队列或其他异步机制，在缓存过期后，异步地从数据库加载数据并更新缓存。这种方案可以提高系统的响应速度，但需要保证数据的一致性。

代码示例 (Java + RabbitMQ)

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import redis.clients.jedis.Jedis;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.TimeUnit;

public class AsyncCacheService {

    private static final String CACHE_PREFIX = "data:";
    private static final String QUEUE_NAME = "cache_refresh_queue";
    private final Jedis jedis;
    private final Connection connection;
    private final Channel channel;

    public AsyncCacheService(Jedis jedis) throws IOException, TimeoutException {
        this.jedis = jedis;

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost"); // RabbitMQ server address
        connection = factory.newConnection();
        channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    }

    public String getData(String key) throws IOException {
        String cacheKey = CACHE_PREFIX + key;

        String data = jedis.get(cacheKey);
        if (data != null) {
            return data;
        }

        // 异步发送消息，请求更新缓存
        sendCacheRefreshMessage(key);

        // 返回一个占位符，或者直接返回 null (根据实际情况选择)
        return null; // 或者返回一个占位符
    }

    private void sendCacheRefreshMessage(String key) throws IOException {
        String message = key;
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
        System.out.println(" [x] Sent '" + message + "' to refresh cache");
    }

    // 消费者，用于异步更新缓存
    public void startCacheRefreshConsumer() throws IOException {
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String key = new String(delivery.getBody(), StandardCharsets.UTF_8);
            System.out.println(" [x] Received '" + key + "' for cache refresh");

            // 从数据库加载数据
            String data = loadDataFromDatabase(key);

            // 更新缓存
            if (data != null) {
                jedis.setex(CACHE_PREFIX + key, 3600, data); // 设置过期时间为 1 小时
                System.out.println(" [x] Cache refreshed for key: " + key);
            } else {
                System.out.println(" [x] No data found in database for key: " + key);
            }
        };
        try {
            channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private String loadDataFromDatabase(String key) {
        // 模拟从数据库加载数据
        System.out.println("Loading data from database for key: " + key);
        try {
            TimeUnit.SECONDS.sleep(1); // 模拟数据库查询耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        if ("testKey".equals(key)) {
            return "Data from database for testKey";
        }
        return null;
    }

    public void close() throws IOException, TimeoutException {
        channel.close();
        connection.close();
        jedis.close();
    }

    public static void main(String[] args) throws IOException, TimeoutException {
        Jedis jedis = new Jedis("localhost", 6379);

        AsyncCacheService cacheService = new AsyncCacheService(jedis);

        // 启动消费者
        new Thread(() -> {
            try {
                cacheService.startCacheRefreshConsumer();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();

        // 模拟获取数据
        try {
            String data = cacheService.getData("testKey");
            System.out.println("Data: " + data); // 第一次获取返回 null 或占位符

            TimeUnit.SECONDS.sleep(5); // 等待消费者更新缓存

            data = cacheService.getData("testKey");
            System.out.println("Data: " + data); // 第二次获取返回真实数据
        } catch (InterruptedException | IOException e) {
            e.printStackTrace();
        } finally {
            cacheService.close();
        }
    }
}

代码解释:

使用 RabbitMQ 作为消息队列。
getData(String key) 方法中，如果缓存未命中，则发送消息到消息队列，请求更新缓存。
startCacheRefreshConsumer() 方法启动消费者，监听消息队列，接收到消息后，从数据库加载数据并更新缓存。
sendCacheRefreshMessage() 方法用于发送消息到消息队列。

异步更新的优点：

可以提高系统的响应速度。
可以减轻数据库的压力。

异步更新的缺点：

实现较为复杂。
需要保证数据的一致性。
第一次获取数据可能返回空值或占位符。

方案选择的权衡

选择哪种方案取决于具体的业务场景和需求。以下是一些建议：

互斥锁: 适用于数据更新频率较低，对数据一致性要求较高的场景。
永不过期: 适用于热点数据，对数据一致性要求较高，并且能够容忍一定的缓存占用。
提前更新: 适用于数据更新频率较低，能够提前预测热点数据的场景。
Null值占位: 适用于缓存穿透和缓存击穿同时存在，并且能够容忍一定的缓存占用。
异步更新: 适用于对响应速度要求较高，能够容忍一定的数据不一致性的场景。

方案	优点	缺点	适用场景
互斥锁	简单易懂，有效防止缓存击穿	性能较低，可能导致死锁	数据更新频率较低，对数据一致性要求较高的场景
永不过期	有效防止缓存击穿，性能较高	需要保证数据一致性，占用较多缓存空间	热点数据，对数据一致性要求较高，能够容忍一定的缓存占用的场景
提前更新	有效防止缓存击穿，提高响应速度	需要提前预测热点数据，如果热点数据变化需要及时更新缓存	数据更新频率较低，能够提前预测热点数据的场景
Null值占位	可以避免缓存穿透，实现简单	需要占用额外的缓存空间，需要处理 NULL 值带来的逻辑复杂性	缓存穿透和缓存击穿同时存在，并且能够容忍一定的缓存占用的场景
异步更新	提高响应速度，减轻数据库压力	实现较为复杂，需要保证数据一致性，第一次获取数据可能返回空值或占位符	对响应速度要求较高，能够容忍一定的数据不一致性的场景

额外考量：熔断与限流

除了上述方案，还可以结合熔断和限流策略，进一步保护数据库，防止因缓存击穿导致的数据库压力过大，最终导致服务崩溃。

熔断: 当数据库的响应时间超过阈值，或者错误率超过阈值时，自动熔断对数据库的访问，防止大量请求继续涌入数据库。
限流: 限制对数据库的访问频率，防止数据库被大量请求压垮。

技术选型和最佳实践

在实际项目中，可以根据具体情况选择合适的技术栈和最佳实践：

缓存: Redis、Memcached 等。
消息队列: RabbitMQ、Kafka 等。
熔断器: Hystrix、Sentinel 等。
监控: Prometheus、Grafana 等。

最佳实践：

细粒度缓存: 尽量缓存细粒度的数据，减少缓存失效的范围。
合理设置过期时间: 根据数据的更新频率，合理设置过期时间，避免缓存过期导致缓存击穿。
监控和报警: 监控缓存的命中率、数据库的响应时间等指标，及时发现和解决问题。
压力测试: 定期进行压力测试，模拟缓存击穿场景，验证系统的稳定性。

解决问题，提升系统健壮性

通过以上介绍，相信大家对微服务架构下缓存击穿的治理方案有了更深入的了解。缓存击穿是一个常见的性能问题，但只要我们采取合适的策略，就能够有效地避免和解决它，提升系统的健壮性和可靠性。希望本次讲座能对大家在实际工作中有所帮助。

预防胜于治疗，持续关注缓存优化

缓存击穿不是一劳永逸的问题，需要持续关注，定期进行性能测试和优化，才能保证系统的稳定性和性能。

综合运用策略，打造稳定高效的缓存体系

实际项目中往往需要结合多种策略，才能有效地解决缓存击穿问题，打造一个稳定高效的缓存体系。

微服务架构下缓存击穿的性能治理：一场技术攻坚战

缓存击穿：隐形的性能杀手

缓存击穿的治理方案

方案选择的权衡

额外考量：熔断与限流

技术选型和最佳实践

解决问题，提升系统健壮性

预防胜于治疗，持续关注缓存优化

综合运用策略，打造稳定高效的缓存体系

发表回复 取消回复

发表回复取消回复