java为我们已经提供了各种锁,为什么还需要分布式锁?

本文涉及的产品
云数据库 Tair(兼容Redis),内存型 2GB
Redis 开源版,标准版 2GB
推荐场景:
搭建游戏排行榜
简介: 目前的项目单体结构的基本上已经没有了,大多是分布式集群或者是微服务这些。既然是多台服务器。就免不了资源的共享问题。既然是资源共享就免不了并发的问题。针对这些问题,redis也给出了一个很好的解决方案,那就是分布式锁。这篇文章主要是针对为什么需要使用分布式锁这个话题来展开讨论的。

一、前言


既然是分布式锁,这就说明服务器不是一台,可能是很多台。我们使用一个案例,来一步一步说明。假设某网站有一个秒杀商品,一看还有100件,于是陕西、江苏、西藏等地的人都看到了这个活动,于是开始进行疯狂秒杀。假设这个秒杀商品的数量值保存在一个redis数据库中。

v2-10688d00fafad1f261cb603d0abd6c2f_1440w.jpg

但是不同地区的用户使用不同的服务器进行秒杀。这样就形成了一个集群访问的方式。

v2-ccb8761d7e11012973c1825f3ac1cf61_1440w.jpg

方式我们使用Springboot来整合redis。


二、项目搭建准备


(1)添加pom依赖


<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>
        </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>

(2)添加属性配置

# Redis数据库索引(默认为0)
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码(默认为空)
spring.redis.password=
# 连接池最大连接数(使用负值表示没有限制) 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间(使用负值表示没有限制) 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0

(3)新建config包,创建RedisConfig类

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Serializable> 
            redisTemplate(LettuceConnectionFactory connectionFactory) {
        RedisTemplate<String, Serializable> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate;
    }
}

(4)新建controller,创建Mycontroller类

@RestController
public class MyController {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @GetMapping("/test")
    public String deduceGoods(){
        int goods =Integer.parseInt(stringRedisTemplate.opsForValue().get("goods"));
        int realGoods = goods-1;
        if(goods>0){
            stringRedisTemplate.opsForValue().set("goods",realGoods+"");
            return "你已经成功秒杀商品,此时还剩余:" + realGoods + "件";
        }else{
            return "商品已经售罄,欢迎下次活动";
        }
    }
}

很简单的一个整合教程。这个端口是8080,我们复制一份这个项目,把端口改成8090,并且以nginx作负载均衡搭建集群。现在环境我们已经整理好了。下面我们就开始进行分析。


三、为什么需要分布式锁


阶段一:采用原生方式


我们使用多个线程访问8080这个端口。因为没有加锁,此时肯定会出现并发问题。因此我们可能会想到,既然这个goods是一个共享资源,而且是多线程访问的,就立马能想到java中的各种锁了,最有名的就是synchronized。所以我们不如对上面的代码进行优化。


阶段二:使用synchronized加锁


此时我们对代码修改一下:

@RestController
public class MyController {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @GetMapping("/test")
    public String deduceGoods(){
        synchronized (this){
            int goods =Integer.parseInt(stringRedisTemplate.opsForValue().get("goods"));
            int realGoods = goods-1;
            if(goods>0){
                stringRedisTemplate.opsForValue().set("goods",realGoods+"");
                return "你已经成功秒杀商品,此时还剩余:" + realGoods + "件";
            }else{
                return "商品已经售罄,欢迎下次活动";
            }
        }
    }
}

看到没,现在我们使用synchronized关键字加上锁,这样多个线程并发访问的时候就不会出现数据不一致等各种问题了。这种方式在单体结构下的确有用。目前的项目单体结构的很少,一般都是集群方式的。此时的synchronized就不再起作用了。为什么synchronized不起作用了呢?


我们采用集群的方式去访问秒杀商品(nginx为我们做了负载均衡)。就会看到数据不一致的现象。也就是说synchronized关键字的作用域其实是一个进程,在这个进程下面的所有线程都能够进行加锁。但是多进程就不行了。对于秒杀商品来说,这个值是固定的。但是每个地区都可能有一台服务器。这样不同地区服务器不一样,地址不一样,进程也不一样。因此synchronized无法保证数据的一致性。


阶段三:分布式锁


上面synchronized关键字无法保证多进程的锁机制,为了解决这个问题,我们可以使用redis分布式锁。现在我们把代码再进行修改一下:

@RestController
public class MyController {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @GetMapping("/test")
    public String deduceGoods(){
      Boolean result = stringRedisTemplate.opsForValue().setIfAbsent("lock","冯冬冬");
      if(!result){
           return "其他人正在秒杀,无法进入";
      }
      int goods =Integer.parseInt(stringRedisTemplate.opsForValue().get("goods"));
      int realGoods = goods-1;
      if(goods>0){
          stringRedisTemplate.opsForValue().set("goods",realGoods+"");
          System.out.println("你已经成功秒杀商品,此时还剩余:" + realGoods + "件");
      }else{
          System.out.println("商品已经售罄,欢迎下次活动");
      }
      stringRedisTemplate.delete("lock");
      return "success";
    }
}

就是这么简单,我们只是加了一句话,然后进行判断了一下。其实setIfAbsent方法的作用就是redis中的setnx。意思是如果当前key已经存在了,就不做任何操作了,返回false。如果当前key不存在,那我们就可以操作。最后别忘了释放这个key,这样别人就可以再进来实时秒杀操作。


当然这里只是给出一个最基本的案例,其实分布式锁实现起来步骤还是比较多的,而且里面很多坑也没有给出。我们随便解决几个:


阶段四:分布式锁优化


(1)第一个坑:秒杀商品出现异常,最终无法释放lock分布式锁


public String deduceGoods() throws Exception{
    Boolean result = stringRedisTemplate.opsForValue().setIfAbsent("lock","冯冬冬");
    if(!result){
       return "其他人正在秒杀,无法进入";
    }
    try {
       int goods =Integer.parseInt(stringRedisTemplate.opsForValue().get("goods"));
       int realGoods = goods-1;
       if(goods>0){
           stringRedisTemplate.opsForValue().set("goods",realGoods+"");
           System.out.println("你已经成功秒杀商品,此时还剩余:" + realGoods + "件");
       }else{
           System.out.println("商品已经售罄,欢迎下次活动");
       }
    }finally {
       stringRedisTemplate.delete("lock");
    }
    return "success";
}

此时我们加一个try和finally语句就可以了。最终一定要删除lock。


(2)第二个坑:秒杀商品时间太久,其他用户等不及


public String deduceGoods() throws Exception{
    stringRedisTemplate.expire("lock",10, TimeUnit.MILLISECONDS);
    Boolean result = stringRedisTemplate.opsForValue().setIfAbsent("lock","冯冬冬");
    if(!result){
       return "其他人正在秒杀,无法进入";
    }
    try {
       int goods =Integer.parseInt(stringRedisTemplate.opsForValue().get("goods"));
       int realGoods = goods-1;
       if(goods>0){
           stringRedisTemplate.opsForValue().set("goods",realGoods+"");
           System.out.println("你已经成功秒杀商品,此时还剩余:" + realGoods + "件");
       }else{
           System.out.println("商品已经售罄,欢迎下次活动");
       }
    }finally {
       stringRedisTemplate.delete("lock");
    }
    return "success";
}

给其添加一个过期时间,也就是说如果10毫秒内没有秒杀成功,就表示秒杀失败,换下一个用户。


(3)第三个坑:高并发场景下,秒杀时间太久,锁永久失效问题


我们刚刚设置的锁过期时间是10毫秒,如果一个用户秒杀时间是15毫秒,这也就意味着他可能还没秒杀成功,就有其他用户进来了。当这种情况过多时,就可能有大量用户还没秒杀成功其他大量用户就进来了。有可能其他用户提前删除了lock,但是当前用户还没有秒杀成功。最终造成数据的不一致。看看如何解决:

public String deduceGoods() throws Exception{
    String user = UUID.randomUUID().toString();
    stringRedisTemplate.expire("lock",10, TimeUnit.MILLISECONDS);
    Boolean result = stringRedisTemplate.opsForValue().setIfAbsent("lock",user);
    if(!result){
       return "其他人正在秒杀,无法进入";
    }
    try {
       int goods =Integer.parseInt(stringRedisTemplate.opsForValue().get("goods"));
       int realGoods = goods-1;
       if(goods>0){
           stringRedisTemplate.opsForValue().set("goods",realGoods+"");
           System.out.println("你已经成功秒杀商品,此时还剩余:" + realGoods + "件");
       }else{
           System.out.println("商品已经售罄,欢迎下次活动");
       }
    }finally {
       if(user.equals(stringRedisTemplate.opsForValue().get("lock"))){
                 stringRedisTemplate.delete("lock");
       }
    }
    return "success";
}

也就是说,我们在删除lock的时候判断是不是当前的线程,如果是那就删除,如果不是那就不删除,这样就算别的线程进来也不会乱删lock,造成混乱。


OK,到目前为止基本上把分布式锁的缘由介绍了一遍。对于分布式锁redisson完成的相当出色,下篇文章也将围着绕Redisson来介绍一下分布式如何实现,以及其中的原理。

相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务,基于高可靠双机热备架构及可无缝扩展的集群架构,满足高读写性能场景及容量需弹性变配的业务需求。 产品详情:https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验:数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引,您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接,领取免费ECS&amp;RDS资源,30分钟完成数据库上云实战!https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
相关文章
|
12天前
|
缓存 Java
java中的公平锁、非公平锁、可重入锁、递归锁、自旋锁、独占锁和共享锁
本文介绍了几种常见的锁机制,包括公平锁与非公平锁、可重入锁与不可重入锁、自旋锁以及读写锁和互斥锁。公平锁按申请顺序分配锁,而非公平锁允许插队。可重入锁允许线程多次获取同一锁,避免死锁。自旋锁通过循环尝试获取锁,减少上下文切换开销。读写锁区分读锁和写锁,提高并发性能。文章还提供了相关代码示例,帮助理解这些锁的实现和使用场景。
java中的公平锁、非公平锁、可重入锁、递归锁、自旋锁、独占锁和共享锁
|
15天前
|
存储 NoSQL Java
Java调度任务如何使用分布式锁保证相同任务在一个周期里只执行一次?
【10月更文挑战第29天】Java调度任务如何使用分布式锁保证相同任务在一个周期里只执行一次?
41 1
|
1月前
|
缓存 NoSQL Java
大数据-50 Redis 分布式锁 乐观锁 Watch SETNX Lua Redisson分布式锁 Java实现分布式锁
大数据-50 Redis 分布式锁 乐观锁 Watch SETNX Lua Redisson分布式锁 Java实现分布式锁
59 3
大数据-50 Redis 分布式锁 乐观锁 Watch SETNX Lua Redisson分布式锁 Java实现分布式锁
|
1月前
|
Java
Java 中锁的主要类型
【10月更文挑战第10天】
|
1月前
|
分布式计算 NoSQL Java
Hadoop-32 ZooKeeper 分布式锁问题 分布式锁Java实现 附带案例和实现思路代码
Hadoop-32 ZooKeeper 分布式锁问题 分布式锁Java实现 附带案例和实现思路代码
43 2
|
1月前
|
安全 Java 开发者
java的synchronized有几种加锁方式
Java的 `synchronized`通过上述三种加锁方式,为开发者提供了从粗粒度到细粒度的并发控制能力,满足了不同场景下的线程安全需求。合理选择加锁方式对于提升程序的并发性能和正确性至关重要,开发者应根据实际应用场景的特性和性能要求来决定使用哪种加锁策略。
17 0
|
1月前
|
Java 应用服务中间件 测试技术
Java21虚拟线程:我的锁去哪儿了?
【10月更文挑战第8天】
32 0
|
1月前
|
NoSQL Java 数据库
Java分布式锁
Java分布式锁
37 0
|
1月前
|
缓存 Java 数据库
JAVA分布式CAP原则
JAVA分布式CAP原则
52 0
|
5月前
|
安全 Java 程序员
Java并发编程中的锁机制与优化策略
【6月更文挑战第17天】在Java并发编程的世界中,锁是维护数据一致性和线程安全的关键。本文将深入探讨Java中的锁机制,包括内置锁、显式锁以及读写锁的原理和使用场景。我们将通过实际案例分析锁的优化策略,如减少锁粒度、使用并发容器以及避免死锁的技巧,旨在帮助开发者提升多线程程序的性能和可靠性。