4.redis的分布式锁以及redis常见的面试题

最新推荐文章于 2024-05-08 08:25:13 发布

Hik58379162

最新推荐文章于 2024-05-08 08:25:13 发布

阅读量407

点赞数 1

文章标签： redis 分布式数据库

本文链接：https://blog.csdn.net/weixin_58379162/article/details/130400947

版权

目录：

1.缓存

2.Redis完成分布式锁

3.redis的面试题。

1. 缓存

当执行增删改操纵时必须保证缓存和数据库数据一致性。---删除缓存

    @Override
    public Student insert(Student student) {
        int i = studentMapper.insert(student);
        return student;
    }

    @Override
    public Integer delete(Integer id) {
        redisTemplate.delete("student::"+id); //缓存与数据库数据保持一致
        int i =studentMapper.deleteById(id);
        return i;
    }

    @Override
    public Student update(Student student) {
        //删除
        redisTemplate.delete("student::"+student.getSid()); //缓存与数据库数据保持一致
        int i = studentMapper.updateById(student);
        return student;
    }

2. redis使用分布式锁

（1）通过使用jmeter压测工具测试

jmeter历史版本下载地址Index of /dist/jmeter/binarieshttps://archive.apache.org/dist/jmeter/binaries/

下面我们通过卖票的方式来看，下面是没有加锁是的票数的相关代码，我们会给予这些代码进行升级

package com.hql.service;


import com.hql.dao.StockDao;
import com.hql.entity.Stock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @program: redis-lock-qy145
 * @description:
 * @author:
 * @create: 2022-03-01 11:13
 **/
@Service
public class StockService_lock_syn {
    @Autowired
    private StockDao stockDao;

    //public static Object o=new Object();
    /**
     * 1.0
     */
   // Lock lock=new ReentrantLock();
    public  String jianStock(Integer pid){
//        try {
           // lock.lock();//加锁
            //1. 查询指定的商品库存
           Stock stock = stockDao.selectById(pid);
            if (stock.getNum() > 0) {
                //2.库存减1
                stock.setNum(stock.getNum() - 1);
                stockDao.updateById(stock);
                System.out.println("库存剩余数量:" + stock.getNum());
                return "减库存成功";
            } else {
                System.out.println("库存不足");
                return "库存减失败";
            }
}
}

由此可以看出没有加锁会出现重卖的现象

同一个库存数被多个线程卖，线程安全问题。

可以使用锁解决:----synchronized和Lock锁

package com.hql.service;


import com.hql.dao.StockDao;
import com.hql.entity.Stock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * @program: redis-lock-qy145
 * @description:
 * @author:
 * @create: 2022-03-01 11:13
 **/
@Service
public class StockService_lock_syn {
    @Autowired
    private StockDao stockDao;

    //public static Object o=new Object();
    /**
     * 1.0
     */
    Lock lock=new ReentrantLock();
    public  String jianStock(Integer pid){
        try {
            lock.lock();//加锁
            //1. 查询指定的商品库存
           Stock stock = stockDao.selectById(pid);
            if (stock.getNum() > 0) {
                //2.库存减1
                stock.setNum(stock.getNum() - 1);
                stockDao.updateById(stock);
                System.out.println("库存剩余数量:" + stock.getNum());
                return "减库存成功";
            } else {
                System.out.println("库存不足");
                return "库存减失败";
            }
        }
        finally {
            lock.unlock(); //释放锁
        }

    }
}

上面的synchronized或Lock锁是否适合集群模式|分布式系统。不适合、因为synchronized都是基于JVM的本地锁。

项目集群

配置nginx

启动nginx

jmeter压测

两台集群出现重卖问题。

2.2 使用redis来解决分布式锁

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.12.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.hql</groupId>
    <artifactId>springboot-jedis3</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-jedis3</name>
    <description>springboot-jedis3</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.1</version>
    </dependency>

        <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

package com.hql.service;


import com.hql.dao.StockDao;
import com.hql.entity.Stock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**
 * @program: redis-lock-qy145
 * @description:
 * @author:
 * @create: 2022-03-01 11:13
 **/
@Service
public class StockService_lock_syn {
    @Autowired
    private StockDao stockDao;

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 2.0
     */
    public  String jianStock(Integer pid){
        //占锁
        ValueOperations<String, String> forValue = redisTemplate.opsForValue();
        Boolean aBoolean = forValue.setIfAbsent("product::" + pid, "", 30, TimeUnit.SECONDS);
        //占锁失败
        while (!aBoolean){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //占锁成功
        try {
            //1. 查询指定的商品库存
            Stock stock = stockDao.selectById(pid);
            if (stock.getNum() > 0) {
                //2.库存减1
                stock.setNum(stock.getNum() - 1);
                stockDao.updateById(stock);
                System.out.println("库存剩余数量:" + stock.getNum());
                return "减库存成功";
            } else {
                System.out.println("库存不足");
                return "库存减失败";
            }
        }finally {
            //释放锁资源
            redisTemplate.delete("product::"+pid);
        }

    }
}

如果你的业务代码的执行时间超过30s，当前线程删除的是其他线程的锁资源。 --watchDog机制

每个10s检测当前线程是否还持有所资源，如果持有则为当前线程延迟。---可以自己设置watchDog机制，---第三方Redission完美的解决分布式锁。

<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.13.4</version>
</dependency>

（2）main函数

package com.hql;


import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class SpringbootJedis3Application {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootJedis3Application.class, args);
    }
    @Bean //创建redisson交于spring容器来管理
    public RedissonClient redisson() {
        Config config = new Config();
       // config.setLockWatchdogTimeout(300);
        config.useSingleServer().setAddress("redis://192.168.244.128:6379");
        RedissonClient redisson = Redisson.create(config);
        return redisson;
    }

}

（3）使用

package com.hql.service;


import com.hql.dao.StockDao;
import com.hql.entity.Stock;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**
 * @program: redis-lock-qy145
 * @description:
 * @author:
 * @create: 2022-03-01 11:13
 **/
@Service
public class StockService_lock_syn {
    @Autowired
    private StockDao stockDao;
@Autowired
private RedissonClient redisson;
    /**
     * 3.0
     * @param pid
     * @return
     */
    public  String jianStock(Integer pid){
        RLock lock = redisson.getLock("product" + pid);
        try {
            lock.lock(30, TimeUnit.SECONDS);//加锁: 如果程序执行是出现一次
            //1. 查询指定的商品库存
            Stock stock = stockDao.selectById(pid);
            if (stock.getNum() > 0) {
                //2.库存减1
                stock.setNum(stock.getNum() - 1);
                stockDao.updateById(stock);
                System.out.println("库存剩余数量:" + stock.getNum());
                return "减库存成功";
            } else {
                System.out.println("库存不足");
                return "库存减失败";
            }
        }finally {
            lock.unlock();
        }

    }
}

3. redis面试题

一、Redis是什么？

redis是使用C语言编写的一个高速缓存数据，它以key-value形式存储数据，而且它支持的数据类型非常丰富。

二、Redis都有哪些使用场景？

1.热点数据的缓存

2.计时器

3.排行榜

4.实现分布式锁

5.使用session的共享

三、Redis支持的数据类型有哪些？

String,List,Set,Hash,Zset

四、Redis为什么是单线程的？

因为redis是基于内存的操作，cpu不会成为redis的瓶颈，Redis的瓶颈最有可能是机器内存的大小或者网络带宽。既然单线程容易实现，而且CPU不会成为瓶颈，那就顺理成章地采用单线程的方案了

五Redis真的是单线程的吗？

不是，比如RDB中的bgsave时创建一个子线程

六、Redis持久化有几种方式？

RDB:

AOF:

七、什么是缓存穿透？怎么解决

恶意的查询数据库中不存在的数据和缓存中不存在的数据，这些请求都会访问数据库，会给数据造成很大的压力

情景: 比如id不合法

确实数据库中不存在

解决: 1. 在controller加校验

2. 我们可以在缓存中存入一个空对象，但是对象的过期时间不要太长，一般不会超过5分钟。

3. 可以使用布隆过滤器

八、怎么保证缓存和数据库数据的一致性？

1.设置合理的过期时间

2.当执行增删改时需要删除缓存数据

九，Redis，什么是缓存雪崩？怎么解决？

缓存雪崩:就是在某一时刻出现大量数据过期，而这时就有大量的请求访问该数据，这种现象叫做缓存雪崩。

什么情况下会出现大量数据过期:

项目刚刚上线
redis服务器宕机
缓存数据真实过期

解决方案:

1.上线前预热数据。

2.设置集群

3设置过期时间时要分散设置。

十、Redis怎么实现分布式锁？

使用redis中的setnx命令--占锁，当业务代码执行完毕后是否锁资源，而释放锁的命令是del。

十一， redis在实现分布式锁式有什么缺陷

超时问题: 业务代码执行时间超过锁时间。使用:watchDog机制。我们使用第三方:redisson

十二、Redis 淘汰策略有哪些？

Hik58379162

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
4.redis的分布式锁以及redis常见的面试题

因为redis是基于内存的操作，cpu不会成为redis的瓶颈，Redis的瓶颈最有可能是机器内存的大小或者网络带宽。既然单线程容易实现，而且CPU不会成为瓶颈，那就顺理成章地采用单线程的方案了恶意的查询数据库中不存在的数据和缓存中不存在的数据，这些请求都会访问数据库，会给数据造成很大的压力情景: 比如id不合法确实数据库中不存在解决: 1. 在controller加校验2. 我们可以在缓存中存入一个空对象，但是对象的过期时间不要太长，一般不会超过5分钟。3. 可以使用布隆过滤器。
复制链接

扫一扫