redis实现分布式锁

最新推荐文章于 2024-04-10 23:15:20 发布
最新推荐文章于 2024-04-10 23:15:20 发布
阅读量259 收藏
点赞数
文章标签： 分布式锁 redisson
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40964170/article/details/118178586
版权

分布式锁原理和使用

使用redis实现所有的分布式锁

	/**
	 * 需求：获取三级分类数据
     * 使用redis做分布式锁 
     * 利用 redis中 set k v nx 原理做分布式锁
     */
	@Override
    public Map<String, List<Catelog2Vo>> getCatalogJson() throws Exception {
        //1、加入缓存逻辑，缓存中的数据都是json字符串，json跨语言跨平台
        ValueOperations<String, String> ops = redisTemplate.opsForValue();
        //2、如果缓存中没有查找出数据
        String json = ops.get("catalogJson");
        if (StringUtils.isEmpty(json)) {
            System.out.println("缓存不命中，查询数据库");
            //3、就从数据库中继续查找
            Map<String, List<Catelog2Vo>> catalogJsonFromDb = getCatalogJsonFromDbWithRedisLock();
            //返回查出的数据
            return catalogJsonFromDb;
        }
        System.out.println("缓存命中，不用查数据库，直接查缓存即可");
        //5、如果缓存中有数据，则直接返回查到的数据，且将返回的json字符串转为指定的对象
        Map<String, List<Catelog2Vo>> result = JSON.parseObject(json, new TypeReference<Map<String, List<Catelog2Vo>>>() {
        });
        return result;
    }

    /**
     * 2、此方法是专门做分布式锁处理
     * @return
     */
    public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbWithRedisLock() throws Exception {
        String uuid = UUID.randomUUID().toString();
        //占用分布式锁，去redis占坑
        //Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "111");
        //占用分布式锁，去redis占坑，设置过期时间必须和加锁同步
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 300, TimeUnit.SECONDS);
        if (lock) {
            Map<String, List<Catelog2Vo>> dataFromDb;
            try {
                //如果是true，代表占坑成功，加锁成功，执行业务
                dataFromDb = getDataFromDb();
            } finally {
                //删除锁，从数据库获取数据后就要删除锁
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
                redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Arrays.asList("lock"), uuid);
            }
            return dataFromDb;
        } else {
            System.out.println("获取分布式锁失败...等待重试...");
            //加锁失败...重试机制
            //休眠一百毫秒
            try { TimeUnit.MILLISECONDS.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }
            return getCatalogJsonFromDbWithRedisLock();
        }
    }

    /**
     * 3、此方法是从数据库获取分类数据
     * @return
     */
    private Map<String, List<Catelog2Vo>> getDataFromDb() {
        //得到锁以后，我们应该再去缓存中确定一次，如果没有才需要继续查询
        String catalogJson = redisTemplate.opsForValue().get("catalogJson");
        if (!StringUtils.isEmpty(catalogJson)) {
            //缓存不为空直接从缓存中获取数据
            Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJson, new TypeReference<Map<String, List<Catelog2Vo>>>() {});
            return result;
        }
        System.out.println("查询了数据库");

        /**
         * 将数据库的多次查询变为一次，查出所有数据
         */
        List<CategoryEntity> selectList = this.baseMapper.selectList(null);
        //1、查出所有分类
        //1、1）查出所有一级分类
        List<CategoryEntity> level1Categorys = getParent_cid(selectList, 0L);

        //封装数据
        Map<String, List<Catelog2Vo>> parentCid = level1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
            //1、每一个的一级分类,查到这个一级分类的二级分类
            List<CategoryEntity> categoryEntities = getParent_cid(selectList, v.getCatId());
            //2、封装上面的结果
            List<Catelog2Vo> catelog2Vos = null;
            if (categoryEntities != null) {
                catelog2Vos = categoryEntities.stream().map(l2 -> {
                    Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName().toString());

                    //1、找当前二级分类的三级分类封装成vo
                    List<CategoryEntity> level3Catelog = getParent_cid(selectList, l2.getCatId());

                    if (level3Catelog != null) {
                        List<Catelog2Vo.Category3Vo> category3Vos = level3Catelog.stream().map(l3 -> {
                            //2、封装成指定格式
                            Catelog2Vo.Category3Vo category3Vo = new Catelog2Vo.Category3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
                            return category3Vo;
                        }).collect(Collectors.toList());
                        catelog2Vo.setCatalog3List(category3Vos);
                    }

                    return catelog2Vo;
                }).collect(Collectors.toList());
            }

            return catelog2Vos;
        }));

        //3、将查到的数据放入缓存,将对象转为json
        String valueJson = JSON.toJSONString(parentCid);
        redisTemplate.opsForValue().set("catalogJson", valueJson, 1, TimeUnit.DAYS);

        return parentCid;

    }
	
	//4、从列表中获取到指定父id下的所有子分类数据
	public List<CategoryEntity> getParent_cid(List<CategoryEntity> selectList, Long parentCid) {
        //查询出指定父分类id下的所有 子分类数据
        List<CategoryEntity> categoryEntities = selectList.stream().filter(item -> item.getParentCid().equals(parentCid)).collect(Collectors.toList());
        return categoryEntities;
    }

上面的lua脚本写法每次用分布式锁时比较麻烦，我们可以采用redisson现有框架

https://redis.io/topics/distlock

Redisson框架

redis官网： http://www.redis.cn/commands/set.html

the Redlock algorithm实现redis分布式锁：https://redis.io/topics/distlock
在这里插入图片描述
redisson官方文档java版： https://github.com/redisson/redisson
在这里插入图片描述

环境搭建

导入依赖

<!--redis原生依赖，后面直接用启动器-->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.13.4</version>
</dependency>
这个用作连续，后面可以使用redisson-spring-boot-starter

开启配置https://github.com/redisson/redisson/wiki/2.-%E9%85%8D%E7%BD%AE%E6%96%B9%E6%B3%95

@Configuration
public class MyRedisConfig {

    // redission通过redissonClient对象使用 // 如果是多个redis集群，可以配置
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient(){
        // 创建单例模式的配置
        Config config = new Config();
        config.useSingleServer().setAddress("192.168.56.10：6379");
        //根据config创建出实例
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }
}

测试redisson注入spring是否成功

@RunWith(SpringRunner.class)
@SpringBootTest
public class GulimallProductApplicationTests {

    @Autowired
    RedissonClient redissonClient;

	@Test
    public void testRedisson(){
        System.out.println(redissonClient);
    }
}

Distributed locks and synchronizers 分布式锁和同步器

分布式锁官网

1、可重入锁（Reentrant Lock）

分布式锁：github.com/redisson/redisson/wiki/8.-分布式锁和同步器

A调用B。AB都需要同一锁，此时可重入锁就可以重入，A就可以调用B。不可重入锁时，A调用B将死锁

// 参数为锁名字
RLock lock = redissonClient.getLock("CatalogJson-Lock");//该锁实现了JUC.locks.lock接口
lock.lock();//阻塞等待
// 解锁放到finally // 如果这里宕机：有看门狗，不用担心
lock.unlock();

基于Redis的Redisson分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。

锁的续期：大家都知道，如果负责储存这个分布式锁的Redisson节点宕机以后，而且这个锁正好处于锁住的状态时，这个锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟（每到20s就会自动续借成30s，是1/3的关系），也可以通过修改Config.lockWatchdogTimeout来另行指定。

// 加锁以后10秒钟自动解锁，看门狗不续命
// 无需调用unlock方法手动解锁
lock.lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
   try {
     ...
   } finally {
       lock.unlock();
   }
}
如果传递了锁的超时时间，就执行脚本，进行占锁;
如果没传递锁时间，使用看门狗的时间，占锁。如果返回占锁成功future，调用future.onComplete();
没异常的话调用scheduleExpirationRenewal(threadId);
重新设置过期时间，定时任务;
看门狗的原理是定时任务：重新给锁设置过期时间，新的过期时间就是看门狗的默认时间;
锁时间/3是定时任务周期;

Redisson同时还为分布式锁提供了异步执行的相关方法：

RLock lock = redisson.getLock("anyLock");
lock.lockAsync();
lock.lockAsync(10, TimeUnit.SECONDS);
Future<Boolean> res = lock.tryLockAsync(100, 10, TimeUnit.SECONDS);

RLock对象完全符合Java的Lock规范。也就是说只有拥有锁的进程才能解锁，其他进程解锁则会抛出IllegalMonitorStateException错误。但是如果遇到需要其他进程也能解锁的情况，请使用分布式信号量Semaphore 对象.

@ResponseBody
    @GetMapping(value = "/hello")
    public String hello() {

        //1、获取一把锁，只要锁的名字一样，就是同一把锁
        RLock myLock = redissonClient.getLock("my-lock");

        //2、加锁
        myLock.lock();      //阻塞式等待。默认加的锁都是30s
        //1）、锁的自动续期，如果业务超长，运行期间自动锁上新的30s。不用担心业务时间长，锁自动过期被删掉
        //2）、加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认会在30s内自动过期，不会产生死锁问题

		//最佳实战：自己指定锁时间，时间长点即可
        // myLock.lock(10,TimeUnit.SECONDS);   //10秒钟自动解锁,自动解锁时间一定要大于业务执行时间
        //问题：在锁时间到了以后，不会自动续期
        //1、如果我们传递了锁的超时时间，就发送给redis执行脚本，进行占锁，默认超时就是 我们制定的时间
        //2、如果我们指定锁的超时时间，就使用 lockWatchdogTimeout = 30 * 1000 【看门狗默认时间】
        //只要占锁成功，就会启动一个定时任务【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】,每隔10秒都会自动的再次续期，续成30秒
        // internalLockLeaseTime 【看门狗时间】 / 3， 10s
        try {
            System.out.println("加锁成功，执行业务..." + Thread.currentThread().getId());
            try { TimeUnit.SECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            //3、解锁  假设解锁代码没有运行，Redisson会不会出现死锁
            System.out.println("释放锁..." + Thread.currentThread().getId());
            myLock.unlock();
        }
        return "hello";
    }

返回结果

加锁成功，执行业务...123
释放锁...123
加锁成功，执行业务...116
释放锁...116
加锁成功，执行业务...115
释放锁...115

源码探究

//如果自己加锁时设置了锁过期时间，即可不手动unlock，到期也会自动锁释放
	myLock.lock(30,TimeUnit.SECONDS);

	//进入redissonLock
	public void lock(long leaseTime, TimeUnit unit) {
        try {
            this.lock(leaseTime, unit, false);
        } catch (InterruptedException var5) {
            throw new IllegalStateException();
        }
    }

	private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException {
        long threadId = Thread.currentThread().getId();
        Long ttl = this.tryAcquire(-1L, leaseTime, unit, threadId);
        if (ttl != null) {
            RFuture<RedissonLockEntry> future = this.subscribe(threadId);
            if (interruptibly) {
                this.commandExecutor.syncSubscriptionInterrupted(future);
            } else {
                this.commandExecutor.syncSubscription(future);
            }

//进入tryAcquire
    private Long tryAcquire(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
        return (Long)this.get(this.tryAcquireAsync(waitTime, leaseTime, unit, threadId));
    }


//进入tryAcquireAsync
	private <T> RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
        if (leaseTime != -1L) {
            return this.tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
        } else {
            RFuture<Long> ttlRemainingFuture = this.tryLockInnerAsync(waitTime, this.commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
            ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
                if (e == null) {
                    if (ttlRemaining == null) {
                        this.scheduleExpirationRenewal(threadId);
                    }

                }
            });
            return ttlRemainingFuture;
        }
    }

	//如果自己设置了锁过期时间，进入tryLockInnerAsync，直接就会执行lua脚本
	<T> RFuture<T> tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
        this.internalLockLeaseTime = unit.toMillis(leaseTime);
        return this.evalWriteAsync(this.getName(), LongCodec.INSTANCE, command, "if (redis.call('exists', KEYS[1]) == 0) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; return redis.call('pttl', KEYS[1]);", Collections.singletonList(this.getName()), this.internalLockLeaseTime, this.getLockName(threadId));
    }

//看到了看门狗的自动续约时间
this.internalLockLeaseTime = commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout();

this.lockWatchdogTimeout = 30000L;

小结
实际中推荐使用自定义加锁并设置过期时间，例如业务执行需要20秒，我们设置锁过期时间为30秒，这样即使不手动添加unlock，30秒到期后自动就会释放锁，而且也省去了看门狗的续约时间。

2、公平锁和非公平锁

redisson默认是非公平锁，例如5个人排队打饭，第一个人打完后，剩下人没有秩序一拥而上抢着打饭，公平锁是剩下人排着队一个个等待着打饭，如果每个人打饭5秒，最后一个人至少等待25秒。

RLock fairLock = redisson.getFairLock("anyLock");
// 最常见的使用方法
fairLock.lock();

// 10秒钟以后自动解锁
// 无需调用unlock方法手动解锁
fairLock.lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = fairLock.tryLock(100, 10, TimeUnit.SECONDS);
...
fairLock.unlock();

3、读写锁（ReadWriteLock）

基于Redis的Redisson分布式可重入读写锁RReadWriteLock Java对象实现了java.util.concurrent.locks.ReadWriteLock接口。其中读锁和写锁都继承了RLock接口。

分布式可重入读写锁允许同时有多个读锁和一个写锁处于加锁状态

	/**
     * 保证一定能读到最新数据，修改期间，写锁是一个排它锁（互斥锁、独享锁），读锁是一个共享锁
     * 写锁没释放读锁必须等待
     * 读 + 读 ：相当于无锁，并发读，只会在Redis中记录好，所有当前的读锁。他们都会同时加锁成功
     * 写 + 读 ：必须等待写锁释放
     * 写 + 写 ：阻塞方式
     * 读 + 写 ：有读锁。写也需要等待
     * 只要有读或者写的存都必须等待
     * @return
     */
	@ResponseBody
    @GetMapping(value = "/write")
    public String writeValue() {
        RReadWriteLock lock = redissonClient.getReadWriteLock("lock");
        RLock rLock = lock.writeLock();
        rLock.lock();
        String s = "";
        try {
            //1、该数据加写锁，读数据加读锁
            s = UUID.randomUUID().toString();
            Thread.sleep(30000);
            redisTemplate.opsForValue().set("writeValue",s);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            rLock.unlock();
        }
        return s;
    }

    @ResponseBody
    @GetMapping(value = "/read")
    public String readValue() {
        RReadWriteLock lock = redissonClient.getReadWriteLock("lock");
        RLock rLock = lock.readLock();
        rLock.lock();
        String s = "";
        try {
            s = redisTemplate.opsForValue().get("writeValue");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            rLock.unlock();
        }
        return s;
    }

小结
写锁方法写数据期间，读锁方法只能一直等待，当数据写完后，读锁方法就会立刻获取到写锁方法的最新数据

4、闭锁（CountDownLatch）

基于Redisson的Redisson分布式闭锁（CountDownLatch）Java对象RCountDownLatch采用了与java.util.concurrent.CountDownLatch相似的接口和用法。

以下代码只有offLatch()被调用5次后 setLatch()才能继续执行

/**
     * 放假、锁门
     * 1班没人了
     * 5个班，全部走完，我们才可以锁大门
     * 分布式闭锁
     */
    @ResponseBody
    @GetMapping(value = "/lockDoor")
    public String CountDownLatch() throws Exception{
        RCountDownLatch lock = redissonClient.getCountDownLatch("lock");
        lock.trySetCount(5);
        //等待闭锁完成
        lock.await();
        return "放假了";
    }

    @ResponseBody
    @GetMapping("/gogo/{id}")
    public String go(@PathVariable("id") Long id){
        RCountDownLatch lock = redissonClient.getCountDownLatch("lock");
        lock.countDown();
        return "ok";
    }

因为上的是同一把锁，只有当countDown减完后，才不会继续await，返回 放假了

5、信号量（Semaphore）

信号量为存储在redis中的一个数字，当这个数字大于0时，即可以调用acquire()方法增加数量，也可以调用release()方法减少数量，但是当调用release()之后小于0的话方法就会阻塞，直到数字大于0

基于Redis的Redisson的分布式信号量（Semaphore）Java对象RSemaphore采用了与java.util.concurrent.Semaphore相似的接口和用法。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。

@ResponseBody
    @GetMapping("/park")
    public String park() throws Exception{
        RSemaphore park = redissonClient.getSemaphore("park");
        //获取一个信号、获取一个值,占一个车位
        park.acquire(1);
        boolean flag = park.tryAcquire();
        if (flag){
            //执行业务

        }else {
            return "error";
        }
        return "ok+>" + flag;
    }

    @ResponseBody
    @GetMapping("/go")
    public String go(){
        RSemaphore park = redissonClient.getSemaphore("park");
        //释放一个车位
        park.release(1);
        return "ok";
    }

停车场案例，开走一个车信号量增加1个，停进来一个车信号量减1个

分布式锁 数据库和缓存一致性解决

问题：
我们查询数据，会先去数据库中查找，查找后更新到缓存中，数据库发生修改后，下次查找还是会先去缓存中，这样就会导致数据库和缓存数据不一致问题

双写模式：写数据库后，写缓存

  • 问题：并发时，2写进入，写完DB后都写缓存。有暂时的脏数据

失效模式：写完数据库后，删缓存

  • 问题：还没存入数据库呢，线程2又读到旧的DB了
  • 解决：缓存设置过期时间，定期更新
  • 解决：写数据写时，加分布式的读写锁

解决方案：

  • 如果是用户纬度数据（订单数据、用户数据），这种并发几率非常小，不用考虑这个问题，缓存数据加上过期时间，每隔一段时间触发读的主动更新即可
  • 如果是菜单，商品介绍等基础数据，也可以去使用canal订阅binlog的方式
  • 缓存数据+过期时间也足够解决大部分业务对于缓存的要求
  • 通过加锁保证并发读写，写写的时候按顺序排好队。读读无所谓。所以适合使用读写锁。（业务不关心脏数据，允许临时脏数据可忽略）

小结

  • 我们能放入缓存的数据本就不应该是实时性、一致性要求超高的。所以缓存数据的时候加上过期时间，保证每天拿到当前最新数据即可
  • 我们不应该过度设计，增加系统的复杂性
  • 遇到实时性、一致性要求高的数据，就应该查数据库，即使慢点
廉小雨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java基于redis实现分布式锁代码实例
08-19
主要介绍了Java基于redis实现分布式锁代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Redis实现分布式锁(附源码+讲义)
07-01
分布式锁有很多种解决方案，今天我们要讲的是怎么使用缓存数据库Redis来实现分布式锁。 课程目标:  理解redis分布式锁的应用场景  掌握redis分布式锁的实现原理  掌握redis分布式锁在微服务项目中的应用  掌握...
三级分类业务改造-使用缓存
小生不才的博客
12-29 821
1.使用redis做缓存 /** * 渲染对应的二三级分类数据 * 往缓存中放的是JSON,取出来的也是JSON，可逆转为能用的对象类型 * json跨语言跨平台兼容 * @return */ @Override public Map<String, List<Catelog2Vo>> getCatalogJson() { String catelogJSON = stringRedisTempla
Redis实现分布式锁
热门推荐
07-27 3万+
分布式锁及实现方案
详解Redis分布式锁（图文并茂，手把手搭建服务，一文轻松搞定
最新发布
m0_74931167的博客
04-10 713
无论是哪家公司，都很重视Spring框架技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，好了希望这篇文章对大家有帮助！一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
详解 Redis 分布式锁的 5 种方案
竹林幽深
10-16 1293
基于上面本地锁的问题，我们需要一种支持分布式集群环境下的锁：查询 DB 时，只有一个线程能访问，其他线程都需要等待第一个线程释放锁资源后，才能继续执行。生活中的案例：可以把锁看成房门外的一把锁，所有并发线程比作人，他们都想进入房间，房间内只能有一个人进入。当有人进入后，将门反锁，其他人必须等待，直到进去的人出来。我们来看下分布式锁的基本原理，如下图所示：我们来分析下上图的分布式锁：1.前端将 10W 的高并发请求转发给四个题目微服务。2.每个微服务处理 2.5 W 个请求。
Redis(进阶)-----Redis实现分布式锁
weixin_43994761的博客
06-07 910
在多线程的环境下，为了保证一个代码块在同一时间只能由一个线程访问，Java中我们一般可以使用synchronized语法和ReetrantLock去保证，这实际上是本地锁的方式。但是现在公司都是流行分布式架构，在分布式环境下，如何保证不同节点的线程同步执行呢？实际上，对于分布式场景，我们可以使用分布式锁，它是控制分布式系统之间互斥访问共享资源的一种方式。
redis实现分布式锁,自旋式加锁,lua原子性解锁
07-16
redis实现分布式锁,自旋式加锁,lua原子性解锁
基于redis实现分布式锁的原理与方法
12-14
redis实现分布式锁 数据库实现分布式锁 zk实现分布式锁 今天我们介绍通过redis实现分布式锁。实际上这三种和java对比看属于一类。都是属于程序外部锁。 原理剖析 上述三种分布式锁都是通过各自为依据对各个请求...
谈谈Redis分布式锁的正确实现方法
12-16
前言 最近在参加学校安排的实训任务，我们小组需完成一套分布式&微服务跨境电商，虽然这题目看起来有点老套，并且队友多是 Java 技术栈，所以我光荣（被迫） 的成为了一名前端，并顺路使用 PHP 的 Swoole 帮助负责服务器端的同学编写了几个微服务模块。在小组成员之间的协作中，还是出现了不少有趣的火花。 在昨天 review 队友代码的过程中，发现了我们组分布式锁的写法似乎有点问题，实现代码如下： 加锁部分 解锁部分 主要原理是使用了 redis 的 setnx 去插入一组 key-value，其中 key 要上锁的标识（在项目中是锁死用户 userId），如果上锁失败则返回 fa
Redis分布式锁
lxzGood的博客
03-17 2398
Redis分布式锁 什么是分布式锁？ 分布式锁:满足分布式系统或集群模式下多进程可见并且互斥的锁。 分布式锁的实现 分布式锁的核心是实现多进程之间的互斥，而满足这一点的方式有很多,常见的有三种: MySql Redis Zookeeper 互斥 利用mysql本身的互斥锁机制 利用setnx这样的互斥命令 利用节点的唯一性和有序性实现互斥 高可用 好 好 好 高性能 一般 好 一般 安全性 断开连接，自动释放锁 利用锁超时时间 临时节点，断开连接自动释放 基于Redis
Redis的分布式锁详解
yifeiliu338的博客
03-03 869
（3）为了有效解决既保证锁完全有效性 和 性能高效问题：antirez又提出了“延迟重启”的概念，redis同步到磁盘方式保持默认的每秒1次，在redis崩溃单机后（无论是一个还是所有），先不立即重启它，而是等待TTL时间后再重启，这样的话，这个节点在重启前所参与的锁都会过期，它在重启后就不会对现有的锁造成影响，缺点是在TTL时间内服务相当于暂停状态；redisson在获取锁之后，会维护一个看门狗线程，在每一个锁设置的过期时间的1/3处，如果线程还没执行完任务，则不断延长锁的有效期。
面试整理-redis实现分布式锁
weixin_41953641的博客
11-17 1720
redis
分布式锁的实现(redis)
2301_78102191的博客
06-15 1173
我们看到foo.lock的value值为时间戳，所以要在多客户端情况下，保证锁有效，一定要同步各服务器的时间，如果各服务器间，时间有差异。锁的超时与否，严格依赖时间戳，时间戳本身也是有精度限制，假如我们的时间精度为秒，从加锁到执行操作再到解锁，一般操作肯定都能在一秒内完成。然后都通过getset去拿到了旧值，在对比了旧值和之前值之后，如果相等，那么说明“我”成功修改了旧值，那么我就拿到了锁。思路是：你降级你的锁，比如给你的锁加上uuid，对不同的业务或者不同的session加上对应粒度的锁。
【Redis】Redis 分布式锁
杜小舟的博客
12-14 524
在单体项目中，我们处理多线程同时操作某一处代码块或者变量时就使用 Synchronized 或者 Lock 锁去保证数据的安全性，但是，现在我们基本上都是使用微服务，当我们把服务部署到多个进程中去，这时候使用 Synchronized 或者 Lock 锁就没办法保证数据的安全性，这时候就需要用到分布式锁。想要实现分布式锁，需要借助一个外部系统，所有进程都去这个系统上申请加锁，而这个外部系统，必须要实现互斥的能力，即两个请求同时进来，只会给一个进程返回成功，另一个返回失败（或等待）。
使用 Redis 如何设计一个分布式锁
养歌的博客
01-14 577
前言 现在的业务应用通常都是微服务架构，如果一个应用部署多个进程，那这多个进程如果需要修改操作同一行记录时，为了避免操作乱序导致数据错误，此时，我们就需要引入分布式锁来解决这个问题了。 而实现分布式锁，大多有以下三种方式实现： 使用 MySQL 实现 使用 Redis 等缓存系统实现 使用 Zookeeper 实现 下面我们以 Redis 来讲解如何实现分布式锁，以及分布式锁的各种安全性问题。 想要实现分布式锁，关键是使用 SETNX 指令。 SETNX SETNX key value 这个命令执行

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值