Redis分布式锁

已于 2024-04-08 21:48:10 修改
阅读量285 收藏 1
点赞数 5
文章标签： redis 分布式 数据库
于 2024-04-08 21:30:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57595670/article/details/137477301
版权

  1. 按照JUC中Lock规范接口编写
  2. Lock加锁
    1. 加锁
    2. 自旋
    3. 续期
  3. unlock解锁
    1. 考虑可重入性的递减，加锁几次就要减锁几次
    2. 到零后，del删除

版本一

        递归重试，容易导致stackoverflowerror，所以不太推荐。

        另外，高并发唤醒后推荐用while 而不是if

package com.njg.redislock.v1;

import cn.hutool.core.util.IdUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.TimeUnit;

@RestController
public class RedisLockV1 {

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    public String sale() {
        String key = "njgLock";
        String uuidValue = IdUtil.randomUUID() + ":" + Thread.currentThread().getId();
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, uuidValue);
        if (!flag){
            // 暂停20s，进行递归重试
            try {
                TimeUnit.MILLISECONDS.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sale();
        }else {
            // 抢锁成功的请求线程，进行正常的业务逻辑操作，扣件库存

        }
        return "";
    }
}

版本二

        不用递归了，高并发下容易出错，用自旋替代递归方法重试调用

        用while替代if

问题：没有过期时间

package com.njg.redislock.v2;

import cn.hutool.core.util.IdUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.TimeUnit;

@RestController
public class RedisLockV2 {

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    public String sale() {
        String key = "njgLock";
        String uuidValue = IdUtil.randomUUID() + ":" + Thread.currentThread().getId();
        while (!stringRedisTemplate.opsForValue().setIfAbsent(key, uuidValue)){
            // 暂停20s，进行递归重试
            try {
                TimeUnit.MILLISECONDS.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 抢锁成功的请求线程，进行正常的业务逻辑操作，扣件库存
        return "";
    }
}

版本三

        宕机与过期，防止死锁

        加锁和过期时间必须同一行，保证原子性

package com.njg.redislock.v3;

import cn.hutool.core.util.IdUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.TimeUnit;

@RestController
public class RedisLockV3 {

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    public String sale() {
        String key = "njgLock";
        String uuidValue = IdUtil.randomUUID() + ":" + Thread.currentThread().getId();
        while (!stringRedisTemplate.opsForValue().setIfAbsent(key, uuidValue, 30L, TimeUnit.SECONDS)) {
            // 暂停20s，进行递归重试
            try {
                TimeUnit.MILLISECONDS.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        stringRedisTemplate.expire(key, 30L, TimeUnit.SECONDS);
        // 抢锁成功的请求线程，进行正常的业务逻辑操作，扣件库存
        return "";
    }
}

版本四

        防止误删key问题

  问题： 1. 判断+del不是一行命令原子操作，需要用lua脚本修改

              2. setnx不满足可冲入性

package com.njg.redislock.v4;

import cn.hutool.core.util.IdUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.concurrent.TimeUnit;

@RestController
public class RedisLockV4 {

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    public String sale() {
        String key = "njgLock";
        String uuidValue = IdUtil.randomUUID() + ":" + Thread.currentThread().getId();
        while (!stringRedisTemplate.opsForValue().setIfAbsent(key, uuidValue, 30L, TimeUnit.SECONDS)) {
            // 暂停20s，进行递归重试
            try {
                TimeUnit.MILLISECONDS.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 抢锁成功的请求线程，进行正常的业务逻辑操作，扣件库存
        try {

        } finally {
            String luaScript =
                    "if redis.call('get',KEYS[1]) == ARGV[1] then " +
                            "return redis.call('del',KEYS[1]) " +
                            "else " +
                            "return 0 " +
                            "end";
            stringRedisTemplate.execute(new DefaultRedisScript<>(luaScript,Long.class), Arrays.asList(key),uuidValue);
        }
        return "";
    }
}

版本五

        lock/unlock+lua

package com.njg.redislock.v5;

import cn.hutool.core.util.IdUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;

import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 自研分布式锁，实现Lock接口
 */
public class RedisDistributedLock implements Lock {


    private StringRedisTemplate stringRedisTemplate;
    private String lockName; //KEYS[1]
    private String uuidValue;// ARGV[1]
    private long expireTime;//ARGV[2]

    public RedisDistributedLock(StringRedisTemplate stringRedisTemplate, String lockName) {
        this.stringRedisTemplate = stringRedisTemplate;
        this.lockName = lockName;
        this.uuidValue = IdUtil.randomUUID() + ":" + Thread.currentThread().getId();
        this.expireTime = 50L;
    }

    @Override
    public void lock() {
        tryLock();
    }


    @Override
    public boolean tryLock() {
        try {
            tryLock(-1, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        if (time == -1) {
            String script =
                    "if redis.call('exists',KEYS[1]) == 0 or redis.call('hexists',KEYS[1],ARGV[1]) == 1 then" +
                            "  redis.call('hincrby',KEYS[1],ARGV[1],1)" +
                            "  redis.call('expire',KEYS[1],ARGV[2])" +
                            "  return 1 " +
                            "else" +
                            "  return 0 " +
                            "end";
            while (!stringRedisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(lockName), uuidValue, String.valueOf(expireTime))) {
                // 暂停60毫秒重试
                TimeUnit.MILLISECONDS.sleep(60);
            }
            return true;
        }
        return false;
    }

    @Override
    public void unlock() {
        String script =
                "if redis.call('hexists',KEYS[1],ARGV[1]) == 0 then " +
                        "  return nil " +
                        "elseif redis.call('hincrby',KEYS[1],ARGV[1],-1) == 0 then " +
                        "  redis.call('del',KEYS[1]) " +
                        "else " +
                        "  return 0 " +
                        "end";

        Long flag = stringRedisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList(lockName), uuidValue);
        if (null == flag){
            throw new RuntimeException("this lock doesn't  exists");
        }

    }


    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public Condition newCondition() {
        return null;
    }
}

使用

package com.njg.redislock.v5;

import cn.hutool.core.util.IdUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;

@RestController
public class RedisLockV5 {

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    Lock lock = new RedisDistributedLock(stringRedisTemplate, "njgLock");


    public String sale() {
        lock.lock();

        // 抢锁成功的请求线程，进行正常的业务逻辑操作，扣件库存
        try {

        } finally {
            lock.unlock();
        }
        return "";
    }
}

版本六

利用工厂模式

问题：测试可重入失败，uuid变 

package com.njg.redislock.v6;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.locks.Lock;

@Component
public class DistributedLockFactory {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private String lockName;

    public Lock getDistributedLock(String lockType){
        if (lockType.equalsIgnoreCase("REDIS")){
            this.lockName = "njgRedisLock";
            return new RedisDistributedLock(stringRedisTemplate,lockName);
        } else if(lockType.equalsIgnoreCase("ZOOKEEPER")){
            this.lockName = "njgZookeeperLockNode";
            // TODO zookeeper版本的分布式锁
        }
        return  null;
    }
}


package com.njg.redislock.v6;

import cn.hutool.core.util.IdUtil;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 自研分布式锁，实现Lock接口
 */
//@Component 引入DistributedLockFactory工厂模式，从工厂获得而不再从spring拿到
public class RedisDistributedLock implements Lock {


    private StringRedisTemplate stringRedisTemplate;
    private String lockName; //KEYS[1]
    private String uuidValue;// ARGV[1]
    private long expireTime;//ARGV[2]

    public RedisDistributedLock(StringRedisTemplate stringRedisTemplate, String lockName) {
        this.stringRedisTemplate = stringRedisTemplate;
        this.lockName = lockName;
        this.uuidValue = IdUtil.randomUUID() + ":" + Thread.currentThread().getId();
        this.expireTime = 50L;
    }

    @Override
    public void lock() {
        tryLock();
    }


    @Override
    public boolean tryLock() {
        try {
            tryLock(-1, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        if (time == -1) {
            String script =
                    "if redis.call('exists',KEYS[1]) == 0 or redis.call('hexists',KEYS[1],ARGV[1]) == 1 then" +
                            "  redis.call('hincrby',KEYS[1],ARGV[1],1)" +
                            "  redis.call('expire',KEYS[1],ARGV[2])" +
                            "  return 1 " +
                            "else" +
                            "  return 0 " +
                            "end";
            while (!stringRedisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(lockName), uuidValue, String.valueOf(expireTime))) {
                // 暂停60毫秒重试
                TimeUnit.MILLISECONDS.sleep(60);
            }
            return true;
        }
        return false;
    }

    @Override
    public void unlock() {
        String script =
                "if redis.call('hexists',KEYS[1],ARGV[1]) == 0 then " +
                        "  return nil " +
                        "elseif redis.call('hincrby',KEYS[1],ARGV[1],-1) == 0 then " +
                        "  redis.call('del',KEYS[1]) " +
                        "else " +
                        "  return 0 " +
                        "end";

        Long flag = stringRedisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList(lockName), uuidValue);
        if (null == flag) {
            throw new RuntimeException("this lock doesn't  exists");
        }

    }


    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public Condition newCondition() {
        return null;
    }
}


package com.njg.redislock.v6;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.locks.Lock;

@RestController
public class RedisLockV6 {

    @Autowired
    private DistributedLockFactory distributedLockFactory;

    public String sale() {

        Lock lock = distributedLockFactory.getDistributedLock("REDIS");
        lock.lock();

        // 抢锁成功的请求线程，进行正常的业务逻辑操作，扣件库存
        try {

        } finally {
            lock.unlock();
        }
        return "";
    }
}

版本七

可重入锁+设计模式

单机+并发+可重入性        测试通过

package com.njg.redislock.v6;

import cn.hutool.core.util.IdUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.locks.Lock;

@Component
public class DistributedLockFactory {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private String lockName;

    private String uuid;

    public DistributedLockFactory() {
        this.uuid = IdUtil.randomUUID();
    }

    public Lock getDistributedLock(String lockType){
        if (lockType.equalsIgnoreCase("REDIS")){
            this.lockName = "njgRedisLock";
            return new RedisDistributedLock(stringRedisTemplate,lockName,uuid);
        } else if(lockType.equalsIgnoreCase("ZOOKEEPER")){
            this.lockName = "njgZookeeperLockNode";
            // TODO zookeeper版本的分布式锁
        }
        return  null;
    }
}

package com.njg.redislock.v6;

import cn.hutool.core.util.IdUtil;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 自研分布式锁，实现Lock接口
 */
//@Component 引入DistributedLockFactory工厂模式，从工厂获得而不再从spring拿到
public class RedisDistributedLock implements Lock {


    private StringRedisTemplate stringRedisTemplate;
    private String lockName; //KEYS[1]
    private String uuidValue;// ARGV[1]
    private long expireTime;//ARGV[2]

    public RedisDistributedLock(StringRedisTemplate stringRedisTemplate, String lockName, String uuidValue) {
        this.stringRedisTemplate = stringRedisTemplate;
        this.lockName = lockName;
        this.uuidValue = uuidValue + ":" + Thread.currentThread().getId();
        this.expireTime = 50L;
    }

    @Override
    public void lock() {
        tryLock();
    }


    @Override
    public boolean tryLock() {
        try {
            tryLock(-1, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        if (time == -1) {
            String script =
                    "if redis.call('exists',KEYS[1]) == 0 or redis.call('hexists',KEYS[1],ARGV[1]) == 1 then" +
                            "  redis.call('hincrby',KEYS[1],ARGV[1],1)" +
                            "  redis.call('expire',KEYS[1],ARGV[2])" +
                            "  return 1 " +
                            "else" +
                            "  return 0 " +
                            "end";
            while (!stringRedisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(lockName), uuidValue, String.valueOf(expireTime))) {
                // 暂停60毫秒重试
                TimeUnit.MILLISECONDS.sleep(60);
            }
            return true;
        }
        return false;
    }

    @Override
    public void unlock() {
        String script =
                "if redis.call('hexists',KEYS[1],ARGV[1]) == 0 then " +
                        "  return nil " +
                        "elseif redis.call('hincrby',KEYS[1],ARGV[1],-1) == 0 then " +
                        "  redis.call('del',KEYS[1]) " +
                        "else " +
                        "  return 0 " +
                        "end";

        Long flag = stringRedisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList(lockName), uuidValue);
        if (null == flag) {
            throw new RuntimeException("this lock doesn't  exists");
        }

    }


    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public Condition newCondition() {
        return null;
    }
}

package com.njg.redislock.v6;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.locks.Lock;

@RestController
public class RedisLockV6 {

    @Autowired
    private DistributedLockFactory distributedLockFactory;

    public String sale() {

        Lock lock = distributedLockFactory.getDistributedLock("REDIS");
        lock.lock();

        // 抢锁成功的请求线程，进行正常的业务逻辑操作，扣件库存
        try {

        } finally {
            lock.unlock();
        }
        return "";
    }
}

版本八

自动续期lua

package com.njg.redislock.v7;

import cn.hutool.core.util.IdUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.locks.Lock;

@Component
public class DistributedLockFactory {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private String lockName;

    private String uuid;

    public DistributedLockFactory() {
        this.uuid = IdUtil.randomUUID();
    }

    public Lock getDistributedLock(String lockType){
        if (lockType.equalsIgnoreCase("REDIS")){
            this.lockName = "njgRedisLock";
            return new RedisDistributedLock(stringRedisTemplate,lockName,uuid);
        } else if(lockType.equalsIgnoreCase("ZOOKEEPER")){
            this.lockName = "njgZookeeperLockNode";
            // TODO zookeeper版本的分布式锁
        }
        return  null;
    }
}

package com.njg.redislock.v7;

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;

import java.util.Arrays;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 自研分布式锁，实现Lock接口
 */
//@Component 引入DistributedLockFactory工厂模式，从工厂获得而不再从spring拿到
public class RedisDistributedLock implements Lock {


    private StringRedisTemplate stringRedisTemplate;
    private String lockName; //KEYS[1]
    private String uuidValue;// ARGV[1]
    private long expireTime;//ARGV[2]

    public RedisDistributedLock(StringRedisTemplate stringRedisTemplate, String lockName, String uuidValue) {
        this.stringRedisTemplate = stringRedisTemplate;
        this.lockName = lockName;
        this.uuidValue = uuidValue + ":" + Thread.currentThread().getId();
        this.expireTime = 50L;
    }

    @Override
    public void lock() {
        tryLock();
    }


    @Override
    public boolean tryLock() {
        try {
            tryLock(-1, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        if (time == -1) {
            String script =
                    "if redis.call('exists',KEYS[1]) == 0 or redis.call('hexists',KEYS[1],ARGV[1]) == 1 then" +
                            "  redis.call('hincrby',KEYS[1],ARGV[1],1)" +
                            "  redis.call('expire',KEYS[1],ARGV[2])" +
                            "  return 1 " +
                            "else" +
                            "  return 0 " +
                            "end";
            while (!stringRedisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(lockName), uuidValue, String.valueOf(expireTime))) {
                // 暂停60毫秒重试
                TimeUnit.MILLISECONDS.sleep(60);
            }
            // 新建一个后台扫描程序，监测key目前的ttl，是否到我们规定的1/2 1/3实现续期
            renewExpire();
            return true;
        }
        return false;
    }

    private void renewExpire() {
        String script = "if redis.call('HEXISTS',KEYS[1],ARGV[1]) == 1 then " +
                "  return redis.call('expire',KEYS[1],ARGV[2]) " +
                "else " +
                "  return 0 " +
                "end";
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                if (stringRedisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(lockName), uuidValue, String.valueOf(expireTime))) {
                    renewExpire();
                }
            }
        }, (this.expireTime * 1000) / 3);
    }

    @Override
    public void unlock() {
        String script =
                "if redis.call('hexists',KEYS[1],ARGV[1]) == 0 then " +
                        "  return nil " +
                        "elseif redis.call('hincrby',KEYS[1],ARGV[1],-1) == 0 then " +
                        "  redis.call('del',KEYS[1]) " +
                        "else " +
                        "  return 0 " +
                        "end";

        Long flag = stringRedisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList(lockName), uuidValue);
        if (null == flag) {
            throw new RuntimeException("this lock doesn't  exists");
        }

    }


    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public Condition newCondition() {
        return null;
    }
}

package com.njg.redislock.v7;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.locks.Lock;

@RestController
public class RedisLockV7 {

    @Autowired
    private DistributedLockFactory distributedLockFactory;

    /**
     * 实现自动续期功能的完善，后台自定义扫描程序，如果规定时间内没有完成业务逻辑，会调用加钟自动续期的脚本
     *
     * @return
     */
    public String sale() {

        Lock lock = distributedLockFactory.getDistributedLock("REDIS");
        lock.lock();

        // 抢锁成功的请求线程，进行正常的业务逻辑操作，扣件库存
        try {

        } finally {
            lock.unlock();
        }
        return "";
    }
}

南山南nathan
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Redis分布式锁的正确使用姿势
主要从事JAVA开发，目前是CSDN博客Java领域新星创作者、阿里云博客专家、担任公司研发经理、技术负责人等。热爱编程，喜欢在Python、C、C++领域探索。
02-23 986
分布式锁在日常开发中，用处非常的多。包括但不限于抢红包，秒杀，支付下单，幂等，等等场景。分布式锁的实现方式有多种，包括redis实现，mysql实现，zookeeper实现等等。而其中redis非常适合作为分布式锁使用，并且在各个公司都大规模的使用。本文将由浅入深的探究Redis分布式锁的实现，最终实现一个可工业使用的Redis分布式锁。欢迎大家一步一步跟读，一起学习一起进步。本文章有借鉴博客园wenbochang博主文章整理！
浅析Redis分布式锁
12-16
前期考虑的方案有采用ZooKeeper分布式任务,Quartz分布式任务调度,但是由于Zookeeper需要增加额外组件,Quartz需要增加表,并且项目中现在已经有Redis这一组件存在,所以考虑采用Redis分布式锁的情况来完成分布式任务...
Redis redisTemplate.execute 执行锁
u010738038的专栏
08-09 3125
代码】Redis redisTemplate.execute 执行锁。
谈谈Redis分布式锁
张彦峰的博客
10-03 1万+
主要内容是关于分布式锁的理论和实践，以及Redisson作为一个分布式锁的实现工具的详细介绍。
redis分布式锁
m0_51290829的博客
02-21 527
解决方案：1.将锁的过期时间设置的长一点 2.使用redisson的watchdog机制给锁续命，给锁一个uuId的标识，没等过期时间进行三分之一进行.通过uuid进行判断是否是自己的锁进行续命。所以 如果能允许少量数据的缺失保证高的效率使用redis分布式锁。，finally中释放锁的操作还未进行，当你再次进行访问的时候，该key的商品还是存在的，无论如何都是访问不到的，这个时候就会。锁续命，给锁一个uuId的标识，没等过期时间进行三分之一进行.通过uuid进行判断是否是自己的锁进行续命。
Redis 分布式锁
weixin_43844718的博客
08-23 613
Redis分布式锁应用。提示：以下是本篇文章正文内容，下面案例可供参考在极端的情况下，都会有锁失效或锁冲突的情况出现，建议对分布式锁不要强依赖，没有绝对可靠的分布式锁，分布式锁需要与业务的联动配合更加切实可行，不要造成不必要的损失。
Redis分布式锁及其常见问题解决方案
栗筝i的博客
09-21 3377
Redis 提供了一种简单有效的分布式锁实现方式。其基本思想是使用 Redis 的 SETNX 命令，这个命令可以在键不存在时设置值，如果键已存在则不做任何操作。通过这个原子操作，我们可以实现在多个节点之间的互斥访问。 然而，虽然 Redis 分布式锁的实现相对简单，但在实际使用中还需要考虑很多问题，例如锁的超时和续期问题、锁的公平性问题、网络分区的问题等。在接下来的文章中，我们将详细介绍这些问题以及解决方案。
探讨redis分布式锁
热门推荐
微笑听雨
12-01 1万+
redis分布式锁核心实现
redis分布式锁&redisson
pscool的博客
02-16 1832
利用set nx ex获取锁，并设置过期时间，保存线程标示释放锁时先判断线程标示是否与自己一致，一致则删除锁利用set nx满足互斥性利用set ex保证故障时锁依然能释放，避免死锁，提高安全性利用Redis集群保证高可用和高并发特性Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务，其中就包含了各种分布式锁的实现。
Redis分布式锁存在的问题以及解决方式
个人博客，欢迎收藏。https://xiaoaozz.github.io/
01-18 1488
带你一起解决Redis分布式锁存在的问题。
Java Redis分布式锁的正确实现方式详解
08-25
Java Redis分布式锁的正确实现方式详解 Java Redis分布式锁是指使用Redis实现的分布式锁机制，旨在解决分布式系统中的并发问题。分布式锁有三种实现方式：数据库乐观锁、基于Redis的分布式锁和基于ZooKeeper的...
redis分布式锁.zip
10-18
Redis 分布式锁是分布式系统中解决并发控制和数据一致性问题的一种常见机制。在大型分布式应用中，单机锁无法满足需求，因为它们局限于单个服务器。Redis 的高可用性和低延迟特性使其成为实现分布式锁的理想选择。...
redis分布式锁工具类
09-26
现在很多项目单机版已经不满足了，分布式变得越受欢迎，同时也带来很多问题，分布式锁也变得没那么容易实现，分享一个redis分布式锁工具类，里面的加锁采用lua脚本（脚本比较简单，采用java代码实现，无须外部调用...
Redis分布式锁的实现方式(redis面试题)
09-08
以下我们将详细讨论Redis分布式锁的正确实现方式以及常见的错误实践。 正确实现Redis分布式锁需要考虑以下几个关键点： 1. **互斥性**：同一时刻，只有一个客户端能够持有锁。Redis提供了`SETNX`（Set if Not ...
7.10日学习打卡----初学Redis（五）
m0_74436895的博客
07-11 1097
经历了 1次pipeline(n条命令) = 1次网络时间 + n次命令时间，这大大减少了网络时间的开销，这就是流水线。执行一条命令在redis端可能需要几百微秒，而在网络光纤中传输只花费了13毫秒。注意在执行批量操作而没有使用pipeline功能，会将大量的时间耗费在每一次网络传输的过程上；而使用pipeline后，只需要经过一次网络传输，然后批量在redis端进行命令操作。这会大大提高了效率。
Redis 第一次作业
最新发布
Floating_wind的博客
07-15 265
(1） 设置一个hash表，order表里包括的键值信息有：id：1,customer_name：张三。PERSIST name 取消 key （name） 的超时时间。（3）将name列表的尾部元素移除到number列表的头部。查看"系统环境变量"，PATH变量，新增了 Redis的路径。（2） 创建一个hash表，表里的键值批量插入。（3） 获取order对应的map的所有key。（4） 获取order对应的map的键值数量。（2）将列表city里的头部的元素移除。(3) 查看key的超时时间。
redis中的streams实现mq
z3551906947的博客
07-15 406
具体的redis指令就不做过多的分析，接下来就要是通过小徐先生的几张图，来了解里面的具体流程，让大家先清楚一个大概过程，然后再进行深究具体问题。外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传下面这个是别人公众号上面的图，利用这个图，可以很清楚的看到客生产者使用redis的命令将数据放到redis的streams里面之中，然后消费者通过获取信息进行消费，如果消费成功的话，就是要给redis回应一个ack，这样就完美的保证了数据被消费。
# Redis 入门到精通（一）数据类型（2）
段子手168的博客
07-11 947
# Redis 入门到精通（一）数据类型（2） 012-数据类型-hash类型介绍与基本操作 013-数据类型-hash扩展操作与使用注意事项 014-数据类型-hash实现购物车 015-hash实现抢购 016-数据类型-list类型介绍与基本操作 017-数据类型-list阻塞数据获取 018-数据类型-list扩展操作删除数据 019-数据类型-list实现日志消息队列

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值