Java后端开发中的缓存穿透与雪崩问题：如何设计解决方案

微赚淘客系统@聚娃科技

于 2024-10-03 07:15:00 发布

阅读量91

点赞数 2

文章标签： java 缓存开发语言

本文链接：https://blog.csdn.net/qq836869520/article/details/142579929

版权

Java后端开发中的缓存穿透与雪崩问题：如何设计解决方案

大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！

缓存是提高后端服务性能的重要手段之一。然而，缓存穿透和雪崩问题可能会导致服务不可用。本文将探讨这些问题及其解决方案。

缓存穿透

缓存穿透是指查询一个在缓存和数据库中都不存在的数据。这将导致每次请求都要查询数据库，增加数据库的负载。

解决方案

使用布隆过滤器

布隆过滤器可以判断一个元素是否在一个集合中。通过布隆过滤器，我们可以快速判断请求的数据是否存在。

package cn.juwatech.cache;

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;

import java.nio.charset.Charset;

public class BloomFilterExample {

    public static void main(String[] args) {
        BloomFilter<String> filter = BloomFilter.create(Funnels.stringFunnel(Charset.forName("UTF-8")), 1000, 0.01);

        // 添加存在的数据
        filter.put("existsKey1");
        filter.put("existsKey2");

        // 判断数据是否存在
        boolean exists = filter.mightContain("existsKey1"); // true
        boolean notExists = filter.mightContain("notExistsKey"); // false

        System.out.println("exists: " + exists);
        System.out.println("notExists: " + notExists);
    }
}

缓存空对象

对于查询结果为空的情况，可以在缓存中存储一个特殊的空对象，以避免对数据库的查询。

package cn.juwatech.service;

import cn.juwatech.cache.BloomFilterExample;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class CacheService {

    @Autowired
    private BloomFilterExample bloomFilter;

    public Object getFromCache(String key) {
        if (bloomFilter.mightContain(key)) {
            // 从缓存中获取数据
            return cache.get(key);
        }
        // 查询数据库
        Object result = database.query(key);
        if (result == null) {
            // 缓存空对象
            cache.put(key, new NullObject());
            return null;
        }
        cache.put(key, result);
        return result;
    }
}

class NullObject {
    // 空对象
}

缓存雪崩

缓存雪崩是指缓存中大量数据同时失效，导致大量请求直接访问数据库，造成数据库压力过大。

解决方案

使用随机过期时间

为缓存数据设置随机的过期时间，避免大量数据同时失效。

package cn.juwatech.cache;

import java.util.concurrent.TimeUnit;

public class RandomExpiryCache {

    public void putWithRandomExpiry(String key, Object value) {
        int randomExpiry = (int) (Math.random() * 60); // 随机过期时间
        cache.put(key, value, randomExpiry, TimeUnit.SECONDS);
    }
}

使用多级缓存

多级缓存可以提供额外的保护层，即使一级缓存失效，请求还可以访问二级缓存。

package cn.juwatech.cache;

public class MultiLevelCache {

    private Cache primaryCache;
    private Cache secondaryCache;

    public Object get(String key) {
        Object result = primaryCache.get(key);
        if (result == null) {
            result = secondaryCache.get(key);
            if (result != null) {
                primaryCache.put(key, result); // 回填一级缓存
            }
        }
        return result;
    }
}

限流

在数据库层面进行限流，避免数据库被过量请求压垮。

package cn.juwatech.service;

import com.google.common.util.concurrent.RateLimiter;

public class DatabaseService {

    private RateLimiter rateLimiter = RateLimiter.create(10.0); // 每秒10个请求

    public Object query(String key) {
        if (!rateLimiter.tryAcquire()) {
            throw new RuntimeException("请求过于频繁，请稍后再试");
        }
        // 查询数据库
        return database.query(key);
    }
}

熔断机制

当数据库压力过大时，启动熔断机制，拒绝部分请求，防止系统崩溃。

package cn.juwatech.service;

import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixCommandKey;
import com.netflix.hystrix.HystrixThreadPoolKey;
import com.netflix.hystrix.HystrixThreadPoolProperties;

public class CommandWithThreadPool extends HystrixCommand<Object> {

    private final String key;

    protected CommandWithThreadPool(String key) {
        super(HystrixCommandGroupKey.Factory.asKey("ExampleGroup"),
              HystrixCommandKey.Factory.asKey("ExampleCommand"),
              HystrixThreadPoolKey.Factory.asKey("ExampleThreadPool"));
        this.key = key;
    }

    @Override
    protected Object run() {
        return database.query(key);
    }

    public static void main(String[] args) {
        CommandWithThreadPool command = new CommandWithThreadPool("key");
        try {
            Object result = command.execute();
            System.out.println(result);
        } catch (Exception e) {
            System.out.println("服务不可用");
        }
    }
}