分布式锁入门，不信你看不懂 - 优快云博客

最新推荐文章于 2024-07-09 17:08:59 发布

置顶 hzh（LK）

最新推荐文章于 2024-07-09 17:08:59 发布

阅读量428

点赞数 2

CC 4.0 BY-SA版权

分类专栏：分布式文章标签：分布式锁锁分布式分布式锁入门学习 java分布式锁

本文链接：https://blog.youkuaiyun.com/hg123677/article/details/93722496

分布式专栏收录该内容

1 篇文章

订阅专栏

本文深入探讨了锁和分布式锁的概念，解释了为何在多线程和多服务环境中需要使用锁来避免并发冲突。通过具体示例，文章详细介绍了如何利用Redis实现分布式锁，包括代码实现和业务场景应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

什么是锁？

锁就是一个人进入一间房间里做事情，然后把门关上，其他人进不来。我们业务中的锁就是这样的（当然，现实生活中，别人在门外憋不住了，急了还可以把门给踹开）
我们用它就一定有它的好处，为什么需要锁呢？
在多用户环境中，在同一时间可能会有多个用户更新相同的记录，这会产生冲突。这就是著名的并发性问题
说白了，我们在执行代码的时候，如果是单线程执行，锁的用处就不大。但是，如果是多个线程同时执行同一个方法时，就可能会出现多次修改同一变量的情况，这样的结果是无法控制和预料的。所以我们需要一把锁，让某些特定的代码，同一时间，只能是一个线程来执行它，其他线程要等他执行完后再运行。

什么是分布式锁？

在一个服务中，一个线程执行的时候上锁，其他线程知道它在执行，并且上了锁，就在门外等待。那么，如果是多个服务的情况下，一个线程执行的时候，另一个服务的线程怎么就能知道它在执行，并且上锁了呢？这就用到了分布式锁。所谓分布式锁其实和锁的功能是一模一样，它也是悲观锁的一种，（至于悲观锁，这里就不多介绍了）分布式锁的特殊之处就是运用在不同服务之间，一个服务的线程执行方法，加锁，使其他服务的线程知道他加锁了，要等待了，我去。。。，我还能讲的更通俗些么。
分布式锁的实现常用的有redis和zookeeper，介于大多数惯用redis，这里我就以redis举例了

代码实现（详细步骤）

//0、下载redis（建议windows版本）
//1、创建Module
//2、导依赖
   <properties>
        <java.version>1.8</java.version>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.aliyun.openservices</groupId>
            <artifactId>aliyun-log</artifactId>
            <version>0.6.10</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
    
//3、创建RedisApplication
    @SpringBootApplication
    public class RedisApplication {
         public static void main(String[] args) {
             SpringApplication.run(RedisApplication.class,args);
       }
    }

导入ReidsLoke工具类（核心）

/**
 * Created with IntelliJ IDEA.
 * User: 黄志豪.
 * Date: 2018/1/26.
 * Time: 下午 9:30.
 * Explain:
 */
@Component
@Slf4j
public class RedisLock {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    /**
     * 加锁
     * @param key productId - 商品的唯一标志
     * @param value  当前时间+超时时间 也就是时间戳
     * @return
     */
    public  boolean lock(String key,String value){
        if(stringRedisTemplate.opsForValue().setIfAbsent(key,value)){//对应setnx命令
            //可以成功设置,也就是key不存在
            return true;
        }
        //判断锁超时 - 防止原来的操作异常，没有运行解锁操作  防止死锁
        String currentValue = stringRedisTemplate.opsForValue().get(key);
        //如果锁过期
        if(!StringUtils.isEmpty(currentValue) && Long.parseLong(currentValue) < System.currentTimeMillis()){//currentValue不为空且小于当前时间
            //获取上一个锁的时间value
            String oldValue =stringRedisTemplate.opsForValue().getAndSet(key,value);//对应getset，如果key存在
            //假设两个线程同时进来这里，因为key被占用了，而且锁过期了。获取的值currentValue=A(get取的旧的值肯定是一样的),两个线程的value都是B,key都是K.锁时间已经过期了。
            //而这里面的getAndSet一次只会一个执行，也就是一个执行之后，上一个的value已经变成了B。只有一个线程获取的上一个值会是A，另一个线程拿到的值是B。
            if(!StringUtils.isEmpty(oldValue) && oldValue.equals(currentValue) ){
                //oldValue不为空且oldValue等于currentValue，也就是校验是不是上个对应的商品时间戳，也是防止并发1
                return true;
            }
        }
        return false;
    }
    /**
     * 解锁
     * @param key
     * @param value
     */
    public void unlock(String key,String value){
        try {
            String currentValue = stringRedisTemplate.opsForValue().get(key);
            if(!StringUtils.isEmpty(currentValue) && currentValue.equals(value) ){
                stringRedisTemplate.opsForValue().getOperations().delete(key);//删除key
            }
        } catch (Exception e) {
            log.error("[Redis分布式锁] 解锁出现异常了，{}",e);
        }
    }
}

模拟业务代码

在这里插入图片描述
注意：这里我设置的超时时间为2秒
当线程1还没有释放锁（进入方法等待5秒，执行完后才释放锁），但是，当第二个线程进入锁的时候已经是3秒后了，此时已经超过了超时时间，所以一个方法会有2个线程执行，这就违背了设锁的初衷。可以将超时的时间设置为10秒，这样当一个线程进入方法时，相同代码的线程就无法进入锁了

/**
 * Created with IntelliJ IDEA.
 * User: 黄志豪.
 * Date: 2018/1/26.
 * Time: 下午 9:30.
 * Explain:
 */
@Component
public class SeckillService{

    @Autowired
    private RedisLock redisLock;

    private static final int TIMEOUT = 2*1000;//超时时间 10s

    public  void orderProductMocckDiffUser(String productId) {//解决方法一:synchronized锁方法是可以解决的，但是请求会变慢,请求变慢是正常的。主要是没做到细粒度控制。比如有很多商品的秒杀，但是这个把所有商品的秒杀都锁住了。而且这个只适合单机的情况，不适合集群
        //加锁
     long time = System.currentTimeMillis() + TIMEOUT;
     if(!redisLock.lock(productId,String.valueOf(time))){
         throw new SecurityException("请重复再试");
     }
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //解锁
       redisLock.unlock(productId,String.valueOf(time));
    }
}

测试类

@RunWith(SpringRunner.class)
@SpringBootTest(classes = RedisApplication.class)
public class RedisTest {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private SeckillService seckillService;

    @Test
    public void test1() throws InterruptedException {
     for (int i = 0; i < 2; i++) {
         Thread.sleep(3000);
         System.out.println("第"+i+"个线程开始执行");
         new Thread(new Runnable() {
            @Override
            public void run() {
              seckillService.orderProductMocckDiffUser(Thread.currentThread().getName()+"");
            }
         },"hzh").start();
       }
        //防止子线程还没走完，主线程已经结束，报异常
        Thread.sleep(15000);
    }
}