Redis穿透问题解决方案

Art&Code Art&Code 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 900+累计阅读 914平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄7年
关注
原创 最新推荐文章于 2026-07-30 10:23:27 发布 914 阅读 AI 写同款· GEO 优化 ›
深入解析Redis中的缓存穿透问题及解决方案 缓存穿透是指在高并发场景下，恶意用户或系统错误地频繁请求数据库中不存在的数据，导致这些请求绕过缓存直接访问数据库，从而给数据库带来巨大压力，甚至导致数据库崩溃。缓存穿透是Redis应用中常见的问题，但通过布隆过滤器、缓存空对象和接口限流等手段，可以有效缓解甚至解决这一问题。开发者应根据具体场景选择合适的解决方案，并结合实际业务需求进行优化。希望本文能帮助你更好地理解和应对Redis中的缓存穿透问题，提升系统的稳定性和性能。如果你有任何问题或建议，欢迎在评论区留言讨论。 阅读详情

Redis穿透问题解决方案

缓存穿透

　缓存穿透是指用户查询数据，在数据库没有，自然在缓存中也不会有。这样就导致用户查询的时候，在缓存中找不到，每次都要去数据库再查询一遍，然后返回空。这样请求就绕过缓存直接查数据库，这也是经常提的缓存命中率问题。

解决的办法就是：如果查询数据库也为空，直接设置一个默认值存放到缓存，这样第二次到缓冲中获取就有值了，而不会继续访问数据库，这种办法最简单粗暴。

 

把空结果，也给缓存起来，这样下次同样的请求就可以直接返回空了，即可以避免当查询的值为空时引起的缓存穿透。同时也可以单独设置个缓存区域存储空值，对要查询的key进行预先校验，然后再放行给后面的正常缓存处理逻辑。

 

查询查不到的数据，在缓存中没有，而直接走了数据库！ 反反复复的去这么做就崩溃了哦

4没有，redis中没有，然后去DB查询，会导致雪崩效应。称之为 穿透效应。

 

穿透 产生的原因：客户端随机生成不同的key，在redis缓存中没有该数据，数据库也没有该数据。这样的话可能导致一直发生jdbc连接

 

解决方案：

   1、通过网关判断客户端传入对应key的规则，不符合数据库查询规则，直接返回空 

   2、如果使用的key数据库查询不到的话，直接在redis中存一份null结果。 

      在存入id为4的数据库的时候，直接清除对应redis为4的缓存（此时是空哈）

 

废话不多说，上代码：

 pom：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.toov5.architect</groupId>
  <artifactId>architect</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.0.RELEASE</version>
	</parent>
	<dependencies>
		<!-- SpringBoot 对lombok 支持 -->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
		<!-- SpringBoot web 核心组件 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
		</dependency>
		<!-- SpringBoot 外部tomcat支持 -->
		<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
		</dependency>
		<!-- springboot-log4j -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-log4j</artifactId>
			<version>1.3.8.RELEASE</version>
		</dependency>
		<!-- springboot-aop 技术 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>
		<!-- https://mvnrepository.com/artifact/commons-lang/commons-lang -->
		<dependency>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>2.6</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.47</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
		</dependency>
		<dependency>
			<groupId>taglibs</groupId>
			<artifactId>standard</artifactId>
			<version>1.1.2</version>
		</dependency>
		<!--开启 cache 缓存 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-cache</artifactId>
		</dependency>
		<!-- ehcache缓存 -->
		<dependency>
			<groupId>net.sf.ehcache</groupId>
			<artifactId>ehcache</artifactId>
			<version>2.9.1</version><!--$NO-MVN-MAN-VER$ -->
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.1.1</version>
		</dependency>
		<!-- mysql 依赖 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>
		<!-- redis 依赖 -->
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
	</dependencies>
  
</project>

　service:

　

package com.toov5.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.stereotype.Component;

import net.sf.ehcache.Cache;
import net.sf.ehcache.Element;


@Component
public class EhCacheUtils {

    // @Autowired
    // private CacheManager cacheManager;
    @Autowired
    private EhCacheCacheManager ehCacheCacheManager;

    // 添加本地缓存 (相同的key 会直接覆盖)
    public void put(String cacheName, String key, Object value) {
        Cache cache = ehCacheCacheManager.getCacheManager().getCache(cacheName);
        Element element = new Element(key, value);
        cache.put(element);
    }

    // 获取本地缓存
    public Object get(String cacheName, String key) {
        Cache cache = ehCacheCacheManager.getCacheManager().getCache(cacheName);
        Element element = cache.get(key);
        return element == null ? null : element.getObjectValue();
    }

    public void remove(String cacheName, String key) {
        Cache cache = ehCacheCacheManager.getCacheManager().getCache(cacheName);
        cache.remove(key);
    }

}
package com.toov5.service;

import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class RedisService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    //这样该方法支持多种数据类型 
    public void set(String key , Object object, Long time){
        //开启事务权限
        stringRedisTemplate.setEnableTransactionSupport(true);
        try {
            //开启事务
            stringRedisTemplate.multi();
            
            String argString =(String)object;  //强转下
            stringRedisTemplate.opsForValue().set(key, argString);
            
            //成功就提交
            stringRedisTemplate.exec();
        } catch (Exception e) {
            //失败了就回滚
            stringRedisTemplate.discard();
            
        }
        if (object instanceof String ) {  //判断下是String类型不
            String argString =(String)object;  //强转下
            //存放String类型的
            stringRedisTemplate.opsForValue().set(key, argString);
        }
        //如果存放Set类型
        if (object instanceof Set) {
            Set<String> valueSet =(Set<String>)object;
            for(String string:valueSet){
                stringRedisTemplate.opsForSet().add(key, string);  //此处点击下源码看下 第二个参数可以放好多
            }
        }
        //设置有效期
        if (time != null) {
            stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
        
    }
    //做个封装
    public void setString(String key, Object object){
        String argString =(String)object;  //强转下
        //存放String类型的
        stringRedisTemplate.opsForValue().set(key, argString);
    }
    public void setSet(String key, Object object){
        Set<String> valueSet =(Set<String>)object;
        for(String string:valueSet){
            stringRedisTemplate.opsForSet().add(key, string);  //此处点击下源码看下 第二个参数可以放好多
        }
    }
    
    public String getString(String key){
     return    stringRedisTemplate.opsForValue().get(key);
    }
    
    
}
package com.toov5.service;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RequestMapping;

import com.toov5.entity.Users;
import com.toov5.mapper.UserMapper;

import io.netty.util.internal.StringUtil;

@Service
public class SnowslideService {
    @Autowired
    private UserMapper userMapper; 
    @Autowired
    private RedisService redisService;
    
    private Lock lock = new ReentrantLock();
    
    public String getUser01(Long id){
    //定义key， key以当前的类名+方法名+id+参数值
    String key = this.getClass().getName() + "-" + Thread.currentThread().getStackTrace()[1].getMethodName()
                        + "-id:" + id;    
          //1查询redis
    String username = redisService.getString(key);
    if (!StringUtil.isNullOrEmpty(username)) {
        return username;
    }
    String resultUsaerName = null;
    try {
        //开启锁
        lock.lock();
        Users user = userMapper.getUser(id);
        if (username == null) {
            return null;
        }
        resultUsaerName =user.getName();
        redisService.setString(key, resultUsaerName);
    } catch (Exception e) {
        // TODO: handle exception
    }finally {
        //释放锁
        lock.unlock();
    }
          //3直接返回
    return resultUsaerName;
    }
    
    
    
//穿透解决方案    
    public String getUser02(Long id){
    //定义key， key以当前的类名+方法名+id+参数值
    String key = this.getClass().getName() + "-" + Thread.currentThread().getStackTrace()[1].getMethodName()
                        + "-id:" + id;    
          //1查询redis
    System.out.println("查询redis缓存"+"key"+key+".resultUserName");
    String username = redisService.getString(key);
    if (!StringUtil.isNullOrEmpty(username)) {
        return username;
    }
    String resultUsaerName = null;
    //如果数据库中，没有对应的数据信息的时候
       System.out.println("查询数据库：id"+id);
        Users user = userMapper.getUser(id);
        if (user == null) {
            resultUsaerName="${null}";  //做个标记  客户端识别到后 提示下吧
            
        }else {
            resultUsaerName=user.getName();
        }
        System.out.println("写入redis缓存"+"key"+key+".resultUserName"+resultUsaerName);
        redisService.setString(key, resultUsaerName);

          //3直接返回
    return resultUsaerName;
    }
    
    
}
package com.toov5.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSONObject;
import com.toov5.entity.Users;
import com.toov5.mapper.UserMapper;


import io.netty.util.internal.StringUtil;

@Component
public class UserService {
    @Autowired
    private EhCacheUtils ehCacheUtils;
    @Autowired
    private RedisService redisService;
    @Autowired
    private UserMapper userMapper;
    //定义个全局的cache名字
    private String cachename ="userCache";
    
    public Users getUser(Long id){
        //先查询一级缓存  key以当前的类名+方法名+id+参数值
        String key = this.getClass().getName() + "-" + Thread.currentThread().getStackTrace()[1].getMethodName()
                + "-id:" + id;
        //查询一级缓存数据有对应值的存在 如果有 返回
        Users user = (Users)ehCacheUtils.get(cachename, key);
        if (user != null) {
            System.out.println("key"+key+",直接从一级缓存获取数据"+user.toString());
            return user;
        }
        //一级缓存没有对应的值存在,接着查询二级缓存    
        // redis存对象的方式  json格式 然后反序列号
        String userJson = redisService.getString(key);
        //如果rdis缓存中有这个对应的值，修改一级缓存    最下面的会有的 相同会覆盖的    
        if (!StringUtil.isNullOrEmpty(userJson)) {  //有 转成json
            JSONObject jsonObject = new JSONObject();//用的fastjson
            Users resultUser = jsonObject.parseObject(userJson,Users.class);
            ehCacheUtils.put(cachename, key, resultUser);
            return resultUser;
        }
        //都没有 查询DB 
        Users user1 = userMapper.getUser(id);
        if (user1 == null) {
            return null;
        }
        //保证两级缓存有效期相同！？   一级缓存时间-二级缓存执行的时间
        //一级缓存时间 等于 二级缓存剩下的时间   
        //存放到二级缓存 redis中
        redisService.setString(key, new JSONObject().toJSONString(user1));
        //存放到一级缓存 Ehchache
        ehCacheUtils.put(cachename, key, user1);
        return user1;
    }
    
    
    
}

mapper

package com.toov5.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;

import com.toov5.entity.Users;
//引入的jar包后就有了这个注解了 非常好用 （配置缓存的基本信息）
@CacheConfig(cacheNames={"userCache"})  //缓存的名字  整个类的
public interface UserMapper {
    @Select("SELECT ID ,NAME,AGE FROM users where id=#{id}")
    @Cacheable //让这个方法实现缓存 查询完毕后 存入到缓存中  不是每个方法都需要缓存呀！save()就不用了吧
    Users getUser(@Param("id") Long id);
}

entity

package com.toov5.entity;

import java.io.Serializable;

import lombok.Data;

@Data
public class Users implements Serializable{
  private String name;
  private Integer age;
}

controller

package com.toov5.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.toov5.service.SnowslideService;

@RestController
public class UserRedisController {
   @Autowired
   private SnowslideService snowslideService;
   
   @RequestMapping("/getUser02")
   public String getUser02(Long id){
       return snowslideService.getUser02(id); 
   }
   
}
package com.toov5.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.toov5.entity.Users;
import com.toov5.service.UserService;

@RestController
public class IndexController {
    @Autowired
    private UserService userService;
    
    @RequestMapping("/userId")
    public Users getUserId(Long id){
        return userService.getUser(id);  
    }
    
   
}

启动类

package com.toov5.app;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@EnableCaching //开启缓存
@MapperScan(basePackages={"com.toov5.mapper"})
@SpringBootApplication(scanBasePackages={"com.toov5.*"})
public class app {
   public static void main(String[] args) {
    SpringApplication.run(app.class, args);
}
    
}

yml

###端口号配置
server:
  port: 8080
###数据库配置 
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver
    test-while-idle: true
    test-on-borrow: true
    validation-query: SELECT 1 FROM DUAL
    time-between-eviction-runs-millis: 300000
    min-evictable-idle-time-millis: 1800000
# 缓存配置读取
  cache:
    type: ehcache
    ehcache:
      config: classpath:app1_ehcache.xml
  redis:
    database: 0 
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0
    timeout: 10000
    cluster:
      nodes:
        - 192.168.91.5:9001
        - 192.168.91.5:9002
        - 192.168.91.5:9003
        - 192.168.91.5:9004
        - 192.168.91.5:9005
        - 192.168.91.5:9006

　

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">

	<diskStore path="java.io.tmpdir/ehcache-rmi-4000" />


	<!-- 默认缓存 -->
	<defaultCache maxElementsInMemory="1000" eternal="true"
		timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="true"
		diskSpoolBufferSizeMB="30" maxElementsOnDisk="10000000"
		diskPersistent="true" diskExpiryThreadIntervalSeconds="120"
		memoryStoreEvictionPolicy="LRU">
	</defaultCache>
  
	<!-- demo缓存 --><!-- name="userCache" 对应我们在 @CacheConfig(cacheNames={"userCache"}) ！！！！！ -->
	<!--Ehcache底层也是用Map集合实现的 -->
	<cache name="userCache" maxElementsInMemory="1000" eternal="false"
		timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="true"
		diskSpoolBufferSizeMB="30" maxElementsOnDisk="10000000"
		diskPersistent="false" diskExpiryThreadIntervalSeconds="120"
		memoryStoreEvictionPolicy="LRU">  <!-- LRU缓存策略 -->
		<cacheEventListenerFactory
			class="net.sf.ehcache.distribution.RMICacheReplicatorFactory" />
		<!-- 用于在初始化缓存，以及自动设置 -->
		<bootstrapCacheLoaderFactory
			class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory" />
	</cache>
</ehcache>

　再加一个拦截

 

运行结果：

 

 

把空结果，也给缓存起来，这样下次同样的请求就可以直接返回空了，即可以避免当查询的值为空时引起的缓存穿透。同时也可以单独设置个缓存区域存储空值，对要查询的key进行预先校验，然后再放行给后面的正常缓存处理逻辑。

 

注意：再给对应的ip存放真值的时候，需要先清除对应的之前的空缓存。

 

补充热点key

 

热点key:某个key访问非常频繁，当key失效的时候有打量线程来构建缓存，导致负载增加，系统崩溃。

 

解决办法：

①使用锁，单机用synchronized,lock等，分布式用分布式锁。

②缓存过期时间不设置，而是设置在key对应的value里。如果检测到存的时间超过过期时间则异步更新缓存。

③在value设置一个比过期时间t0小的过期时间值t1，当t1过期的时候，延长t1并做更新缓存操作。

　

 

收录于
Redis

当前文章被收录于：

Redis
20 篇文章 0 人学习
订阅专栏 查看详情
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
解锁Cherry Studio高阶玩法：用MCP实现自动化测试与数据爬取 本文深入探讨了如何利用MCP协议与Cherry Studio结合，实现自动化测试与数据爬取的高阶应用。通过Playwright等工具的MCP集成方案，详细解析了自动化测试流水线构建和智能爬虫系统开发的关键技术，显著提升工程效率和系统适应性。 阅读详情

相关推荐

带隙基准电路设计实战：从HSPICE仿真到Virtuoso版图全流程解析

在模拟集成电路设计中，基准电压源是确保系统精度与稳定性的核心模块。其基本原理在于巧妙结合具有正、负温度系数的电压，通过加权求和实现近似零温度系数的稳定输出，这一特性对于高精度数据转换器、电源管理芯片等至关重要。从工程实践角度，利用HSPICE进行深入的直流工作点、温度扫描和工艺角仿真，是验证电路性能、优化温度系数和电源抑制比的关键步骤。而借助Cadence Virtuoso进行版图实现时，必须重点关注电阻与BJT的匹配布局、敏感节点的保护以及电源完整性设计，以确保设计意图在硅片上得以准确呈现。通过完整的从前

weixin_29181861的博客 287

【redis】穿透、击穿、血崩的原因和处理方案

REDIS 缓存穿透，缓存击穿，缓存雪崩原因和解决方案 认识 缓存穿透：key对应的数据在数据源并不存在，每次针对此key的请求从缓存获取不到，请求都会到数据源，从而可能压垮数据源。比如用一个不存在的用户id获取用户信息，不论缓存还是数据库都没有，若黑客利用此漏洞进行攻击可能压垮数据库。 缓存击穿：key对应的数据存在，但在redis中过期，此时若有大量并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。 缓存雪崩：当缓存服务器重启或

wjwoo1的博客 312

图形学常见概念小结

前言：本文记录《unity shader入门精要》和openGL相关学习过程中一些学习要点； 文章目录PBR流程渲染管线细分着色器的底层实现，应用原理常见的色调映射算法openGl和Direct X的区别PBR流程和URP渲染管线Camera loop（剔除）MVP矩阵变换光线追踪前向渲染和延迟渲染shader和材质的区别bloom原理后处理的理解高斯模糊实现原理图像处理中的边缘检测算子 PBR流程 小结：一套基于自然界微平面理论、能量守恒、菲涅尔反射、线性空间等的科学理论所实现的基于物理的渲染系统，包含一

小谁的博客 1163

Redis——缓存穿透问题

缓存穿透指高频查询不存在的数据导致请求直接压垮数据库。

m0_74101628的博客 921

企业级AI Agent平台建设方案

本报告将深入剖析构成一个顶级AI Agent平台的各个功能层面，为构建者提供一份全面的战略蓝图。

分享AI和大数据领域的知识和研究 1582

（保姆式教程：从下数据到画图）python如何利用EOF分析SSTA海温异常现象并画图

保姆式教程，教你如何利用python分析1979-2004年的太平洋地区的海温异常SSTA，并且绘制出空间模态和时间序列的图片。

shayuxing的博客 2万+

Redis—击穿、穿透、雪崩

一. 概念： 1、首先redis击穿有一个前置的条件，就是一定是高并发的情况下才会发生这种情况。一般系统的架构设计会在ngnix或者其他微服务的设计下阻拦很多的并发量，但是难免访问到redis的并发量还是很多，此时才会出现击穿问题 ...

yeshenyuexieriji的博客 1万+

DCDC开关节点SW的Layout抉择：打孔换层与EMI共模辐射的权衡

本文深入探讨了DCDC转换器中开关节点SW的Layout设计对EMI共模辐射的影响。通过分析SW节点的EMI辐射机制、打孔换层对输入环路的影响以及铜皮面积与共模辐射的量化关系，提出了工程实践中的权衡策略和优化方法，帮助工程师在设计中平衡EMI性能和电路效率。

weixin_29722783的博客 246

【Redis】缓存穿透概念及其解决方式

Redis缓存穿透概念及其解决方式

liuwanqing233333的博客 1512

半导体器件仿真：双极型晶体管仿真_15.双极型晶体管的高级仿真技术

双极型晶体管（Bipolar Junction Transistor, BJT）是一种重要的半导体器件，广泛应用于放大、开关和调制等电路中。随着半导体技术的发展，对BJT的仿真要求也越来越高。本节将详细介绍双极型晶体管的高级仿真技术，包括器件模型的选择、仿真参数的优化、温度效应的考虑以及噪声分析等。

2401_87715305的博客 1243

【深度学习新浪潮】OpenClaw跟机器人行业有哪些很好的研究结合点？

OpenClaw正通过"AI大脑+机器人肢体"的深度融合，重新定义机器人与人类的交互方式和自主操作能力。近期ROSClaw框架发布、人形机器人集成和空间计算试验等进展，标志着OpenClaw已从概念验证阶段进入实际应用落地期，为机器人行业带来了自然语言控制普及化具身智能平民化和跨平台开发标准化三大变革机遇。

专注：太空算力、AI infra、异构调度、大模型成本工程 229

Redis——解决缓存穿透三种方式

缓存穿透是指用户查询数据，在数据库没有，自然在缓存中也不会有。这样就导致用户查询的时候，在缓存中找不到，每次都要去数据库再查询一遍，然后返回空( 相当于进行了两次无用的查询 )这样请求就绕过缓存直接查数据库，这也是经常提的缓存命中率问题。客户端发送请求获取数据的时候，在redis中未命中，接着查询数据库也未命中，如果这时候大量请求这些不存在的数据，那么就会给数据库造成一定的压力甚至宕机，这就是 缓存穿透 问题的产生。

weixin_45960654的博客 677

最全教程cadence建立个人CIS数据库

此时如果你删除office365，再装Access数据库，可以安装上，然后你再装office365，系统又会把Access软件给你删除掉，因为冲突了。可以在自己的电脑上新建CIS库，主要包含下面几个内容：数据库文件，原理图封装，PCB封装，数据手册，另外建议做一个器件命名的说明。allegro在调用封装的时候，是看的.psm文件，而不是.dra文件，因此只要是c0402.psm，那么所有的内容都要保持一致。（1）文件夹不要有中文，不要有空格，否则无法识别，可以参考博主的方式，全部使用英文输入法下划线。

D_Katter的博客 249

Redis | Redis缓存穿透、缓存击穿、缓存雪崩问题及解决方案

目录 缓存问题 1. 缓存穿透---查不到 解决方案 2. 缓存击穿---量太大,缓存过期 解决方案 3. 缓存雪崩 解决方案 缓存问题 1. 缓存穿透---查不到 缓存穿透是指用户想查询一个数据，发现Redis中没有，也就是缓存没有命中，就向持久性数据库发起查询，发现数据库也没有这个数据，于是查询失败了。当用户请求很多的情况下，缓存没有命中，数据库也没有数据，会给数据库造成很大的压力，这就是缓存穿透。 解决方案 第一种解决方案：使用布隆过滤器 使用布隆过滤器之后，将存储

quwenjing_blog 6321

efm32 入门.pdf

本PDF共计22页，介绍的是操作驱动API，下载与否自己斟酌。

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表，创建专业级图表以简化复杂的信息。

Redis缓存雪崩、穿透、击穿问题剖析与解决方案

AI学习交流与缓存问题解决方案 摘要：本文首先介绍AI学习交流平台，鼓励读者关注、点赞、收藏和评论以共同探索AI技术。随后重点分析三种常见缓存问题：1）缓存雪崩（大量缓存同时失效），提出随机过期时间、缓存预热等解决方案；2）缓存穿透（查询不存在数据），推荐布隆过滤器、缓存空对象等方法；3）缓存击穿（热点数据失效），建议使用互斥锁机制。针对每种问题，均提供了Java代码示例（如Jedis操作、Redisson分布式锁等），帮助开发者快速实现优化方案，保障系统稳定性。

没事学AI的博客 1853

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员，提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列，各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性，请参见数据手册。有关 ARM Cortex™-M4F 内核的信息，请参见《Cortex™-M4F 技术参考手册》。

Redis缓存相关问题——缓存穿透及解决方案

Redis缓存相关问题——缓存穿透及解决方案

专注分享技术、实用优质教程、资源 1409

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android：LinePhone3.2.7(最新版本)，官网地址：http://www.linphone.org/

Redis缓存穿透问题及解决方案

Redis缓存穿透问题及解决方案

asdfgh0077的博客 99

Redis缓存问题及解决方案(穿透、雪崩、击穿)

缓存穿透指客户端请求的，请求数据时缓存缺失，访问数据库也无对应数据，无法构建缓存。当大量请求到来时，数据库压力骤增，这就是缓存穿透问题。当缓存和数据库数据被误删时恶意攻击，大量请求读取不存在的数据业务。

Java练习生 分享学习笔记 1021

Redis穿透问题原因以及解决方案

是指当客户端请求的数据在缓存和数据库中都不存在，这样缓存不会生效，此时请求会直达DB。如果客户端发送大量并发请求到客户端，DB会受到非常大的压力导致宕机。正常流程图片来源：黑马程序员：缓存NULL值当请求没有命中redis后，且访问DB查不到数据的时候，我们采用在缓存中针对DB中不存在的key存入空值，这样即使数据不存在也可以直接返回一个null值给客户端。：避免大量并发数据打到DB。：占用过多内存导致占用过多Redis资源。：将key的过期时间设置相对短一些以节省Redis以及内存资源。

... 536

Redis 缓存穿透、雪崩和击穿问题及解决方案

在使用 Redis 作为缓存时，可能会遇到 **缓存穿透**、**缓存雪崩** 和 **缓存击穿** 这三种常见问题，它们都会影响系统的稳定性和性能。下面详细讲解它们的定义、成因以及相应的解决方案。

maply的博客 1579

Redis 缓存穿透、缓存击穿与缓存雪崩详解：问题、解决方案与最佳实践

缓存穿透是指查询一个不存在的数据，导致请求直接穿透缓存层，直接访问数据库。由于数据库中也不存在该数据，因此每次请求都会绕过缓存，直接访问数据库，从而导致数据库压力过大。缓存击穿是指某个热点数据在缓存中过期，同时有大量并发请求访问该数据，导致所有请求直接访问数据库，从而导致数据库压力激增。缓存雪崩是指大量缓存数据在同一时间失效，导致大量请求直接访问数据库，从而导致数据库压力激增甚至崩溃。缓存穿透、缓存击穿和缓存雪崩是 Redis 使用过程中常见的问题，它们会导致数据库压力过大甚至系统崩溃。缓存穿透。

秃头之旅 4841

Redis的缓存穿透，雪崩和击穿问题以及分别的解决方案

解决防止误删操作 当前线程超时导致后面的线程进入，当前线程删除后进入线程的锁，导致无锁现象的出现（问题的描述就是，当我们设置了超时时间后，我们的在拿到锁之后但是程序没有执行结束的时候锁被因为超时自动释放掉了，这个时候虽然锁释放掉了但是线程还在继续执行，同时另一个线程进来拿到了锁，但刚好在这是上一个线程执行结束将刚刚才拿到lock锁的这个线程的锁直接删掉了）查询，一个值进来根据哈希算法进行计算将算出来的值对应的二进制数据对应的下标中的数据是否为1，如果所用的哈希算法计算出来的都能对应上则说明存在这个值。

m0_47671062的博客 410

Redis 缓存穿透问题及解决方案

缓存穿透问题 缓存穿透是指查询一个根本不存在的数据，缓存层和存储层都不会命中，通常出于容错的考虑，如果从存储层查不到数据则不写入缓存层。一般对于未命中的数据我们是按照如下方式进行处理的： 1.缓存层不命中。 2.存储层不命中，不将空结果写回缓存。 3.返回空结果。 缓存穿透将导致不存在的数据每次请求都要到存储层去查询，失去了缓存保护后端存储的意义。 缓存穿透问题可能会使后端存储负载加大，由于很多后端存储不具备高并发性，甚至可能造成后端存储宕掉。 方案一：缓存空对象 缓存空对象会有一个必须考虑的问题： 空

master_hxh 282

Redis中缓存雪崩、缓存穿透等问题的解决方案

文章目录缓存雪崩缓存穿透缓存预热缓存更新缓存降级热点数据和冷数据缓存热点key 缓存雪崩 缓存同一时间大面积的失效，所以，后面的请求都会落到数据库上，造成数据库短时间内承受大量请求而崩掉。 解决方案 事前：尽量保证整个 redis 集群的高可用性，发现机器宕机尽快补上。选择合适的内存淘汰策略。 事中：本地ehcache缓存 + hystrix限流&降级，避免MySQL崩掉 事后：利用 r...

ThinkWon的博客 1万+

Redis缓存穿透、击穿、雪崩问题及解决方案

结合业务场景灵活组合策略，监控与自动化运维（如 Key 自动续期）是长期保障。

weixin_43290370的博客 1104

Redis缓存穿透、击穿、雪崩问题原理和解决方案

Redis缓存穿透、击穿、雪崩问题原理和解决方案

kerwin的博客 5482
上一篇： Redis雪崩效应以及解决方案
下一篇： 关于Zookeeper
点赞 0
评论 0
书签 书签 4
Art&Code
Art&Code
博客等级 码龄7年 77粉丝 554原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值