1 什么叫做缓存穿透

缓存穿透只会发生在高并发的时候，就是当有10000个并发进行查询数据的时候，我们一般都会先去redis里面查询进行数据，但是如果redis里面没有这个数据的时候，那么这10000个并发里面就会有很大一部分并发会一下子都去mysql数据库里面进行查询了

2 解决缓存穿透

2.1 首先我模拟一下缓存穿透

比如下面的代码
Java模拟并解决Redis缓存穿透 - 图1
Pom.xml代码

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  6.     <groupId>com.example</groupId>
  7.     <artifactId>springboot</artifactId>
  8.     <version>0.0.1-SNAPSHOT</version>
  9.     <packaging>jar</packaging>
  11.     <name>springboot</name>
  12.     <description>Demo project for Spring Boot</description>
  14.     <parent>
  15.         <groupId>org.springframework.boot</groupId>
  16.         <artifactId>spring-boot-starter-parent</artifactId>
  17.         <version>2.1.1.RELEASE</version>
  18.         <relativePath></relativePath> <!-- lookup parent from repository -->
  19.     </parent>
  21.     <properties>
  22.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  23.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  24.         <java.version>1.8</java.version>
  25.     </properties>
  27.     <dependencies>
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-web</artifactId>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>org.springframework.boot</groupId>
  34.             <artifactId>spring-boot-devtools</artifactId>
  35.         </dependency>
  36.         <dependency>
  37.             <groupId>org.springframework.boot</groupId>
  38.             <artifactId>spring-boot-starter-test</artifactId>
  39.             <scope>test</scope>
  40.         </dependency>
  42.         <dependency>
  43.             <groupId>org.mybatis.spring.boot</groupId>
  44.             <artifactId>mybatis-spring-boot-starter</artifactId>
  45.             <version>1.1.1</version>
  46.         </dependency>
  47.         <dependency>
  48.             <groupId>mysql</groupId>
  49.             <artifactId>mysql-connector-java</artifactId>
  50.         </dependency>
  51.     </dependencies>
  53.     <build>
  54.         <plugins>
  55.             <plugin>
  56.                 <groupId>org.springframework.boot</groupId>
  57.                 <artifactId>spring-boot-maven-plugin</artifactId>
  58.             </plugin>
  59.         </plugins>
  60.     </build>
  63. </project>

Application.properties

  1. server.port=8081
  2. #DB Configuration:
  3. spring.datasource.driverClassName=com.mysql.jdbc.Driver
  4. spring.datasource.url=jdbc:mysql://47.91.248.236:3306/hello?useUnicode=true&characterEncoding=utf8
  5. spring.datasource.username=root
  6. spring.datasource.password=root
  8. #spring集成Mybatis环境
  9. #pojo别名扫描包
  10. mybatis.type-aliases-package=com.itheima.domain
  11. #加载Mybatis映射文件
  12. mybatis.mapper-locations=classpath:mapper/*Mapper.xml

MyController代码，下面的蓝色代码是模仿10000个并发线程

  1. /**
  2.  * sinture.com Inc.
  3.  * Copyright (c) 2016-2018 All Rights Reserved.
  4.  */
  5. package com.itheima.controller;
  7. import com.itheima.mapper.UserMapper;
  8. import com.itheima.domain.User;
  9. import com.itheima.service.UserService;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.web.bind.annotation.PathVariable;
  12. import org.springframework.web.bind.annotation.RequestMapping;
  13. import org.springframework.web.bind.annotation.ResponseBody;
  14. import org.springframework.web.bind.annotation.RestController;
  16. import java.util.HashMap;
  17. import java.util.List;
  18. import java.util.Map;
  20. /**
  21.  * @author xinzhu
  22.  * @version Id: MyController.java, v 0.1 2018年12月05日 下午6:29 xinzhu Exp $
  23.  */
  24. @RestController
  25. public class MyController {
  26.     @Autowired
  27.     private UserService userService;
  29.     @RequestMapping("/hello/{id}")
  30.     @ResponseBody
  31.     public User queryUser(@PathVariable Integer id){
  32.        // 蓝色代码注释开始
  33.        new Thread(){
  34.             @Override
  35.             public void run() {
  36.                 for (int x = 0; x < 10000; x++) {
  37.                     userService.queryUser(id);
  38.                 }
  39.             }
  41.         }.start();
  42.         // 蓝色代码注释结束
  44.         return userService.queryUser(id);
  45.     }
  46. }

User类

  1. /**
  2.  * sinture.com Inc.
  3.  * Copyright (c) 2016-2018 All Rights Reserved.
  4.  */
  5. package com.itheima.domain;
  7. /**
  8.  * @author xinzhu
  9.  * @version Id: User.java, v 0.1 2018年12月06日 下午1:40 xinzhu Exp $
  10.  */
  11. public class User {
  12.     // 主键
  13.     private Integer id;
  14.     // 用户名
  15.     private String username;
  16.     // 密码
  17.     private String password;
  18.     // 姓名
  19.     private String name;
  21.     public void setId(Integer id) {
  22.         this.id = id;
  23.     }
  25.     @Override
  26.     public String toString() {
  27.         return "User{" +
  28.                 "id=" + id +
  29.                 ", username='" + username + '\'' +
  30.                 ", password='" + password + '\'' +
  31.                 ", name='" + name + '\'' +
  32.                 '}';
  33.     }
  35.     public Integer getId() {
  36.         return id;
  37.     }
  40.     public String getUsername() {
  41.         return username;
  42.     }
  45.     public void setUsername(String username) {
  46.         this.username = username;
  47.     }
  49.     public String getPassword() {
  50.         return password;
  51.     }
  54.     public void setPassword(String password) {
  55.         this.password = password;
  56.     }
  58.     public String getName() {
  59.         return name;
  60.     }
  62.     public void setName(String name) {
  63.         this.name = name;
  64.     }
  65. }

UserService

  1. package com.itheima.service;
  3. import com.itheima.domain.User;
  5. public interface UserService {
  6.     public User queryUser(Integer id);
  7. }

UserServiceImpl，下面的蓝色代码就是模仿redis，此时要注意下面的模拟redis的map集合必须放到下面的queryUser的外面，也就是说下面的userMap变量必须是成员变量，不然的话，因为redis是被多个线程共享的，如果你放到下面的queryUser()方法里面，那么就是多个线程有多个userMap集合，下面的代码就是如果查询到数据，那么就用redis里面的，如果查询不到就用数据库里面的

  1. package com.itheima.service;
  3. import com.itheima.domain.User;
  4. import com.itheima.mapper.UserMapper;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  8. import java.util.HashMap;
  9. import java.util.Map;
  11. @Service
  12. public class UserServiceImpl implements UserService {
  13.     @Autowired
  14.     private UserMapper userMapper;
  15.     // 蓝色代码注释开始
  16.     static Map<Integer,User> userMap=new HashMap();
  17.     static {
  18.         User huancun_user =new User();
  19.         huancun_user.setId(1);
  20.         huancun_user.setName("zhangsan");
  21.         huancun_user.setPassword("123");
  22.         huancun_user.setName("张三");
  23.         userMap.put(1,huancun_user);
  24.     }
  25.     // 蓝色代码注释结束
  26.     public User queryUser(Integer id){
  27.         User user=userMap.get(id);
  28.         if(user==null){
  29.             user= userMapper.queryUser(id);
  30.             System.out.println("查询数据库");
  31.             userMap.put(user.getId(),user);
  32.         }else{
  33.             System.out.println("查询缓存");
  34.         }
  35.         return user;
  36.     };
  37. }

SpringbootApplication代码

  1. package com.itheima;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class SpringbootApplication {
  9.     public static void main(String[] args) {
  10.         SpringApplication.run(SpringbootApplication.class, args);
  11.     }
  13. }

数据库里面的数据如下

  1. -- ----------------------------
  2. -- Table structure for `user`
  3. -- ----------------------------
  4. DROP TABLE IF EXISTS `user`;
  5. CREATE TABLE `user` (
  6.   `id` int(11) NOT NULL AUTO_INCREMENT,
  7.   `username` varchar(50) DEFAULT NULL,
  8.   `password` varchar(50) DEFAULT NULL,
  9.   `name` varchar(50) DEFAULT NULL,
  10.   PRIMARY KEY (`id`)
  11. ) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
  13. -- ----------------------------
  14. -- Records of user
  15. -- ----------------------------
  16. INSERT INTO `user` VALUES ('1', 'zhangsan', '123', '张三');
  17. INSERT INTO `user` VALUES ('2', 'lisi', '123', '李四');

然后我们查询下面的链接，因为此时上面的模拟redis的map集合里面没有id值是2的数据，所以此时都是查询数据库，你想这一下子10000并发过去，数据库会有很大压力的，
Java模拟并解决Redis缓存穿透 - 图2
然后打印结果如下，就是打印了很多查询数据库和查询缓存，此时也就说明10000个并发里面有很多去查询了数据库，这个是要避免的，至于为什么有查询缓存的打印，因为我们把查询的数据给放到模拟的redis里面了啊，所以刚开始的一大部分线程都是查询数据库，然后剩下的都是查询模拟的redis缓存里面的数据

  1. 查询数据库
  2. 查询数据库
  3. 查询数据库
  4. 查询数据库
  5. 查询数据库
  6. 查询数据库
  7. 查询数据库
  8. 查询数据库
  9. 查询数据库
  10. 查询数据库
  11. 查询数据库
  12. 查询数据库
  13. 查询数据库
  14. 查询缓存
  15. 查询缓存
  16. 查询缓存
  17. 查询缓存
  18. 查询缓存
  19. 查询缓存
  20. 查询缓存
  21. 查询缓存
  22. 查询缓存
  23. 查询缓存

然后我们使用双重检测锁来解决上面的缓存穿透

我们怎么解决缓存穿透呢，即使10000个并发过来，然后这10000个并发需要的数据在redis里面都没有，那么我们应该第一个线程查询数据里面的数据，然后把这个数据给放到redis里面，然后剩下的9999个线程都到redis里面查询，这样就解决了缓存穿透，所以我们可以把上面的代码变成下面这样
比如下面的代码
Java模拟并解决Redis缓存穿透 - 图3
Pom.xml代码

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  6.     <groupId>com.example</groupId>
  7.     <artifactId>springboot</artifactId>
  8.     <version>0.0.1-SNAPSHOT</version>
  9.     <packaging>jar</packaging>
  11.     <name>springboot</name>
  12.     <description>Demo project for Spring Boot</description>
  14.     <parent>
  15.         <groupId>org.springframework.boot</groupId>
  16.         <artifactId>spring-boot-starter-parent</artifactId>
  17.         <version>2.1.1.RELEASE</version>
  18.         <relativePath></relativePath> <!-- lookup parent from repository -->
  19.     </parent>
  21.     <properties>
  22.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  23.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  24.         <java.version>1.8</java.version>
  25.     </properties>
  27.     <dependencies>
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-web</artifactId>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>org.springframework.boot</groupId>
  34.             <artifactId>spring-boot-devtools</artifactId>
  35.         </dependency>
  36.         <dependency>
  37.             <groupId>org.springframework.boot</groupId>
  38.             <artifactId>spring-boot-starter-test</artifactId>
  39.             <scope>test</scope>
  40.         </dependency>
  42.         <dependency>
  43.             <groupId>org.mybatis.spring.boot</groupId>
  44.             <artifactId>mybatis-spring-boot-starter</artifactId>
  45.             <version>1.1.1</version>
  46.         </dependency>
  47.         <dependency>
  48.             <groupId>mysql</groupId>
  49.             <artifactId>mysql-connector-java</artifactId>
  50.         </dependency>
  51.     </dependencies>
  53.     <build>
  54.         <plugins>
  55.             <plugin>
  56.                 <groupId>org.springframework.boot</groupId>
  57.                 <artifactId>spring-boot-maven-plugin</artifactId>
  58.             </plugin>
  59.         </plugins>
  60.     </build>
  63. </project>

Application.properties

  1. server.port=8081
  2. #DB Configuration:
  3. spring.datasource.driverClassName=com.mysql.jdbc.Driver
  4. spring.datasource.url=jdbc:mysql://47.91.248.236:3306/hello?useUnicode=true&characterEncoding=utf8
  5. spring.datasource.username=root
  6. spring.datasource.password=root
  8. #spring集成Mybatis环境
  9. #pojo别名扫描包
  10. mybatis.type-aliases-package=com.itheima.domain
  11. #加载Mybatis映射文件
  12. mybatis.mapper-locations=classpath:mapper/*Mapper.xml

MyController代码，下面的蓝色代码是模仿10000个并发线程

  1. /**
  2.  * sinture.com Inc.
  3.  * Copyright (c) 2016-2018 All Rights Reserved.
  4.  */
  5. package com.itheima.controller;
  7. import com.itheima.mapper.UserMapper;
  8. import com.itheima.domain.User;
  9. import com.itheima.service.UserService;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.web.bind.annotation.PathVariable;
  12. import org.springframework.web.bind.annotation.RequestMapping;
  13. import org.springframework.web.bind.annotation.ResponseBody;
  14. import org.springframework.web.bind.annotation.RestController;
  16. import java.util.HashMap;
  17. import java.util.List;
  18. import java.util.Map;
  20. /**
  21.  * @author xinzhu
  22.  * @version Id: MyController.java, v 0.1 2018年12月05日 下午6:29 xinzhu Exp $
  23.  */
  24. @RestController
  25. public class MyController {
  26.     @Autowired
  27.     private UserService userService;
  29.     @RequestMapping("/hello/{id}")
  30.     @ResponseBody
  31.     public User queryUser(@PathVariable Integer id){
  32.        // 蓝色代码注释开始
  33.        new Thread(){
  34.             @Override
  35.             public void run() {
  36.                 for (int x = 0; x < 10000; x++) {
  37.                     userService.queryUser(id);
  38.                 }
  39.             }
  41.         }.start();
  42.         // 蓝色代码注释结束
  44.         return userService.queryUser(id);
  45.     }
  46. }

User类

  1. /**
  2.  * sinture.com Inc.
  3.  * Copyright (c) 2016-2018 All Rights Reserved.
  4.  */
  5. package com.itheima.domain;
  7. /**
  8.  * @author xinzhu
  9.  * @version Id: User.java, v 0.1 2018年12月06日 下午1:40 xinzhu Exp $
  10.  */
  11. public class User {
  12.     // 主键
  13.     private Integer id;
  14.     // 用户名
  15.     private String username;
  16.     // 密码
  17.     private String password;
  18.     // 姓名
  19.     private String name;
  21.     public void setId(Integer id) {
  22.         this.id = id;
  23.     }
  25.     @Override
  26.     public String toString() {
  27.         return "User{" +
  28.                 "id=" + id +
  29.                 ", username='" + username + '\'' +
  30.                 ", password='" + password + '\'' +
  31.                 ", name='" + name + '\'' +
  32.                 '}';
  33.     }
  35.     public Integer getId() {
  36.         return id;
  37.     }
  40.     public String getUsername() {
  41.         return username;
  42.     }
  45.     public void setUsername(String username) {
  46.         this.username = username;
  47.     }
  49.     public String getPassword() {
  50.         return password;
  51.     }
  54.     public void setPassword(String password) {
  55.         this.password = password;
  56.     }
  58.     public String getName() {
  59.         return name;
  60.     }
  62.     public void setName(String name) {
  63.         this.name = name;
  64.     }
  65. }

UserService

  1. package com.itheima.service;
  3. import com.itheima.domain.User;
  5. public interface UserService {
  6.     public User queryUser(Integer id);
  7. }

UserServiceImpl，下面的蓝色代码就是模仿redis，此时要注意下面的模拟redis的map集合必须放到下面的queryUser的外面，也就是说下面的userMap变量必须是成员变量，不然的话，因为redis是被多个线程共享的，如果你放到下面的queryUser()方法里面，那么就是多个线程有多个userMap集合，下面的代码就是如果查询到数据，那么就用redis里面的，如果查询不到就用数据库里面的
然后下面的红色代码就是解决上面的缓存穿透问题，使用锁来解决缓存穿透问题，而且叫做双重检测锁，为什么叫做双重检测锁呢，因为有两个if语句，第一个if语句就是为了减少走红色代码里面的同步代码块，因为如果换成里面存在想要的数据，那么就不需要走下面的红色代码里面的同步代码块了，所以有两个if语句，至于为什么要有下面的 user= userMap.get(id);，是因为第一次线程查询把数据放到模仿的redis缓存里面之后，剩下的线程当走到下面的同步代码块的时候，需要在查询一下缓存里面的数据就会发现刚刚第一个线程放到redis里面的数据了，所以才会有下面的红色代码里面的 user= userMap.get(id);

  1. package com.itheima.service;
  3. import com.itheima.domain.User;
  4. import com.itheima.mapper.UserMapper;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  8. import java.util.HashMap;
  9. import java.util.Map;
  11. @Service
  12. public class UserServiceImpl implements UserService {
  13.     @Autowired
  14.     private UserMapper userMapper;
  15.     // 蓝色代码注释开始
  16.     static Map<Integer,User> userMap=new HashMap();
  17.     static {
  18.         User huancun_user =new User();
  19.         huancun_user.setId(1);
  20.         huancun_user.setName("zhangsan");
  21.         huancun_user.setPassword("123");
  22.         huancun_user.setName("张三");
  23.         userMap.put(1,huancun_user);
  24.     }
  25.     // 蓝色代码注释结束
  26.     public User queryUser(Integer id){
  27.         User user=userMap.get(id);
  28.         // 红色代码注释开始
  29.         if(user==null){
  30.             synchronized (this) {
  31.                 user= userMap.get(id);
  32.                 if (null == user) {
  33.                     user= userMapper.queryUser(id);
  34.                     System.out.println("查询数据库");
  35.                     userMap.put(user.getId(),user);
  36.                 }else{
  37.                     System.out.println("查询缓存");
  38.                 }
  39.             }
  40.         }else{
  41.             System.out.println("查询缓存");
  42.         }
  43.         //红色代码注释结束
  44.         return user;
  45.     };
  46. }

数据库里面的数据如下

  1. -- ----------------------------
  2. -- Table structure for `user`
  3. -- ----------------------------
  4. DROP TABLE IF EXISTS `user`;
  5. CREATE TABLE `user` (
  6.   `id` int(11) NOT NULL AUTO_INCREMENT,
  7.   `username` varchar(50) DEFAULT NULL,
  8.   `password` varchar(50) DEFAULT NULL,
  9.   `name` varchar(50) DEFAULT NULL,
  10.   PRIMARY KEY (`id`)
  11. ) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
  13. -- ----------------------------
  14. -- Records of user
  15. -- ----------------------------
  16. INSERT INTO `user` VALUES ('1', 'zhangsan', '123', '张三');
  17. INSERT INTO `user` VALUES ('2', 'lisi', '123', '李四');

然后我们查询下面的链接，因为此时上面的模拟redis的map集合里面没有id值是2的数据，所以此时都是查询数据库，你想这一下子10000并发过去，数据库会有很大压力的，
Java模拟并解决Redis缓存穿透 - 图4
然后打印结果如下，就是就只有第一个打印了查询数据库，然后剩下的都是查询缓存了，这就是解决缓存穿透

  1. 查询数据库
  2. 查询缓存
  3. 查询缓存
  4. 查询缓存
  5. 查询缓存
  6. 查询缓存
  7. 查询缓存
  8. 查询缓存
  9. 查询缓存
  10. 查询缓存
  11. 查询缓存
  12. 查询缓存
  13. 查询缓存
  14. 查询缓存
  15. 查询缓存
  16. 查询缓存
  17. 查询缓存
  18. 查询缓存
  19. 查询缓存
  20. 查询缓存
  21. 查询缓存
  22. 查询缓存

原文链接:https://www.cnblogs.com/mqk100/p/11319758.html