手写一个Redis分布式锁解决实际开发中高并发问题

最新推荐文章于 2023-01-31 17:12:39 发布

置顶疯狂的帆

最新推荐文章于 2023-01-31 17:12:39 发布

阅读量882

点赞数 3

分类专栏： redis 文章标签： redis 分布式

本文链接：https://blog.csdn.net/fan521dan/article/details/104765856

版权

redis 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章目录

场景

多线程高并发卖票问题想必都不陌生，那么如何解决票的超卖问题呢？

接下来我们来一步一步分析

开始之前，先搭建好测试环境

搭建环境

1. 导入依赖

<!-- redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.junit.vintage</groupId>
            <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
    </exclusions>
</dependency>

2. 配置连接redis

# 配置redis ip
spring.redis.host=39.105.232.73
# redis端口
spring.redis.port=6379
# redis密码
spring.redis.password=root
# 最大连接数
spring.redis.jedis.pool.max-active=10
# 线程池中最大的空闲连接数
spring.redis.jedis.pool.max-idle=8
# 最小空闲连接数
spring.redis.jedis.pool.min-idle=1
# 连接池最大阻塞时间 -1 代表没有限制
spring.redis.jedis.pool.max-wait=-1

3. 编写接口

@RestController
public class TicketController {

    @Autowired
    private TicketService ticketService;

    @RequestMapping("sellTicket")
    public String sellTicket() {
        ticketService.sellTicket();
        return "请求成功...";
    }
}

4. 编写业务类

@Service
public class TicketServiceImpl implements TicketService {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private Logger logger = LoggerFactory.getLogger(TicketServiceImpl.class);

    @Override
    public String sellTicket() {
        String ticketStr = stringRedisTemplate.opsForValue().get("ticket");
        int ticket = 0;
        if (null != ticketStr) {
            ticket = Integer.parseInt(ticketStr);
        }
        if (ticket > 0) {
            int ticketNew = ticket - 1;
            stringRedisTemplate.opsForValue().set("ticket", String.valueOf(ticketNew));
            logger.info("当前票的库存为：" + ticketNew);
        } else {
            logger.info("手速不够呀，票已经卖光了...");
        }
        return "抢票成功...";
    }
}

5. 准备测试

准备redis服务，设置redis的键值对：set ticket 10
准备测试软件，这里使用的是 Jmeter

JMeter下载地址

JMeter安装教程

分析解决问题

JMeter测试环境

在这里插入图片描述

这里表示，在一瞬间发送30次请求

若是不加任何更改，直接使用上述业务代码

在这里插入图片描述
可以看出来，在高并发情况下，票的超卖情况很严重，根本无法正常使用

使用 synchronized 关键字

public synchronized String sellTicket() {
    String ticketStr = stringRedisTemplate.opsForValue().get("ticket");
    int ticket = 0;
    if (null != ticketStr) {
        ticket = Integer.parseInt(ticketStr);
    }
    if (ticket > 0) {
        int ticketNew = ticket - 1;
        stringRedisTemplate.opsForValue().set("ticket", String.valueOf(ticketNew));
        logger.info("当前票的库存为：" + ticketNew);
    } else {
        logger.info("手速不够呀，票已经卖光了...");
    }
    return "抢票成功...";
}

在这里插入图片描述

可以看出，在单体应用上，并不会出现票的超卖现象。

但也存在一些问题：

使用 synchronized 关键字加在方法上，程序运行效率会很低
真实情况下，比如 12306 ，要负责全国的火车票，供全国人买票，一台服务器肯定是不够的，但是多台服务器，synchronized 关键字就失效了，它只能锁住一台服务器上的方法，并不能同时作用多台服务器。

分布式架构下的问题

问题1

既然 synchronized 不能解决问题，那么我们可以从redis着手，使用 setnx来模拟一个锁。当一个线程进入到当前方法中，使用 setnx 设置一个键，如果设置成功，就允许继续访问，设置失败，就不能访问该方法；当方法运行完毕时，将这个键删除，下一次再有线程来访问时，就重新执行该操作。

public String sellTicket() {
       String lock="lock";
       // 如果成功设置这个值，证明目前该方法并没有被操作，可以进行卖票操作
       Boolean tag = stringRedisTemplate.opsForValue().setIfAbsent(lock, "");
       if (!tag) { // 如果设置失败，证明当前方法正在被执行，不允许再次执行
           // 实际开发环境应该使用队列来完成访问操作，这里主要探究分布式锁的问题，所以仅仅模拟了场景
           // 不设置回调的话，访问信息会丢失
           sellTicket();
           return "当前访问人数过多，请稍后访问...";
       }
       String ticketStr = stringRedisTemplate.opsForValue().get("ticket");
       int ticket = 0;
       if (null != ticketStr) {
           ticket = Integer.parseInt(ticketStr);
       }
       if (ticket > 0) {
           int ticketNew = ticket - 1;
           stringRedisTemplate.opsForValue().set("ticket", String.valueOf(ticketNew));
           logger.info("当前票的库存为：" + ticketNew);
       } else {
           logger.info("手速不够呀，票已经卖光了...");
       }
       stringRedisTemplate.delete(lock);
       return "抢票成功...";
   }

问题2

上述的代码在程序正常运行下不会出现票超卖的问题，但是我们需要考虑：

如果程序运行中系统出现了异常，导致无法删除lock ，就会造成死锁的问题。也许有人马上就会想到，使用 try{} finally {} ，在finally中进行删除锁的操作。
1. 但是，如果是分布式架构，第一个服务器接收到请求，加了锁，此时第二个服务器也接收到请求，setnx 命令失败，需要执行return操作，根据finally的特性，执行return之前，需要先执行finally里的代码，于是，第二个服务器把锁给删除了，程序中锁失效了，肯定会出现票超卖等一系列问题。
如果程序在运行中直接彻底死了（比如，程序员闲着没事儿，来了个 kill -9；或者断电），就算加了finally，finally也不能执行，还是会出现死锁问题

解决方法：

给锁加一个标识符，只允许自己来操作锁，其他访问程序不能操作锁
还要给锁加一个过期时间，这样就算程序死了，当时间过期后，还是能够继续执行

代码实现

public String sellTicket() {
    String lock="lock";     // 锁的键
    String lockId = UUID.randomUUID().toString(); // 锁的值：唯一标识
    try{
        // 如果成功设置这个值，证明目前该方法并没有被操作，可以进行卖票操作
        // 添加一个过期时间，暂定为 30秒，这里的操作具有原子性，如果过期时间设置失败，键也会设置失败
        Boolean tag = stringRedisTemplate.opsForValue().setIfAbsent(lock, lockId, 30, TimeUnit.SECONDS);
        if (!tag) { // 如果设置失败，证明当前方法正在被执行，不允许再次执行
            // 实际开发环境应该使用队列来完成访问操作，这里主要探究分布式锁的问题，所以仅仅模拟了场景
            // 不设置回调的话，访问信息会丢失
            sellTicket();
            return "当前访问人数过多，请稍后访问...";
        }
        String ticketStr = stringRedisTemplate.opsForValue().get("ticket");
        int ticket = 0;
        if (null != ticketStr) {
            ticket = Integer.parseInt(ticketStr);
        }
        if (ticket > 0) {
            int ticketNew = ticket - 1;
            stringRedisTemplate.opsForValue().set("ticket", String.valueOf(ticketNew));
            logger.info("当前票的库存为：" + ticketNew);
        } else {
            logger.info("手速不够呀，票已经卖光了...");
        }
    } finally {
        // 如果redis中的值，和当前的值一致，才允许删除锁。
        if (lockId.equals(stringRedisTemplate.opsForValue().get(lock))) {
            stringRedisTemplate.delete(lock);
        }
    }
    return "抢票成功...";
}

这里已经基本解决了上述的两个问题。

问题3

为什么是基本呢？还需要考虑一个问题：

如果程序运行的极慢，导致30秒已经到了，锁已经失效了，程序还没有运行完成，这时候，就会有另一个线程总想钻个空子，导致票的超卖问题。

这里我们可以使用 sleep 模拟一下

....
if (ticket > 0) {
    try {
        // 为了测试方便，过期时间和线程暂停时间都改成了3秒
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    int ticketNew = ticket - 1;
    stringRedisTemplate.opsForValue().set("ticket", String.valueOf(ticketNew));
....

这样运行就会出现极其严重的超卖问题

那么该如何设置这个过期时间呢？继续加大？这显然是不合适的，因为无论多么大，总有可能出现问题。

解决方法

我们可以使用守护线程，来保证这个时间永不过期

代码实现

	public String sellTicket() {
        String lock="lock";     // 锁的键
        String lockId = UUID.randomUUID().toString(); // 锁的值：唯一标识
        MyThread myThread = null; // 锁的守护线程
        try{
            // 如果成功设置这个值，证明目前该方法并没有被操作，可以进行卖票操作
            // 添加一个过期时间，暂定为 3 秒，这里的操作具有原子性，如果过期时间设置失败，键也会设置失败
            Boolean tag = stringRedisTemplate.opsForValue().setIfAbsent(lock, lockId, 3, TimeUnit.SECONDS);
            if (!tag) { // 如果设置失败，证明当前方法正在被执行，不允许再次执行
                // 实际开发环境应该使用队列来完成访问操作，这里主要探究分布式锁的问题，所以仅仅模拟了场景
                // 不设置回调的话，访问信息会丢失
                sellTicket();
                return "当前访问人数过多，请稍后访问...";
            }

            // 开启守护线程, 每隔三分之一的时间，给锁续命
            myThread = new MyThread(lock);
            myThread.setDaemon(true);
            myThread.start();

            String ticketStr = stringRedisTemplate.opsForValue().get("ticket");
            int ticket = 0;
            if (null != ticketStr) {
                ticket = Integer.parseInt(ticketStr);
            }
            if (ticket > 0) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                int ticketNew = ticket - 1;
                stringRedisTemplate.opsForValue().set("ticket", String.valueOf(ticketNew));
                logger.info("当前票的库存为：" + ticketNew);
            } else {
                logger.info("手速不够呀，票已经卖光了...");
            }
        } finally {
            // 如果redis中的值，和当前的值一致，才允许删除锁。
            if (lockId.equals(stringRedisTemplate.opsForValue().get(lock))) {
                // 程序运行结束，需要关闭守护线程
                myThread.stop();
                stringRedisTemplate.delete(lock);
                logger.info("释放锁成功...");
            }
        }
        return "抢票成功...";
    }

    /** 使用后台线程进行续命
     *  守护线程
     *    在主线程下 如果有一个守护线程  这个守护线程的生命周期 跟主线程是同生死的
     */
    class MyThread extends Thread{
        String lock;
        MyThread (String lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    // 三分之一的时间
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 假设线程还活着，就要给锁续命
                logger.info("线程续命ing...");
                stringRedisTemplate.expire(lock, 3, TimeUnit.SECONDS);
            }
        }
    }

总结

到这里，我们已经基本实现了redis分布式锁，并且可以在高并发场景下正常运行。

需要注意的是，实现分布式锁的代码肯定不是最佳的，重要的是本文中如何在实际开发中，发现问题并解决问题的思路，学会这种善于思考的思想至关重要！

疯狂的帆

关注

3
点赞
踩
3

收藏

觉得还不错? 一键收藏
3
评论
手写一个Redis分布式锁解决实际开发中高并发问题

文章目录场景搭建环境1. 导入依赖2. 配置连接redis3. 编写接口4. 编写业务类5. 准备测试分析解决问题若是不加任何更改，直接使用上述业务代码使用 synchronized 关键字分布式架构下的问题问题1问题2问题3总结场景多线程高并发卖票问题想必都不陌生，那么如何解决票的超卖问题呢？接下来我们来一步一步分析开始之前，先搭建好测试环境搭建环境1. 导入依赖<!-- r...
复制链接

扫一扫