【代码学习】lua+redis分布式锁代码实现实例

最新推荐文章于 2023-03-30 14:17:17 发布
最新推荐文章于 2023-03-30 14:17:17 发布
阅读量1.3k 收藏 2
点赞数 1
分类专栏： redis 文章标签： redis 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41358574/article/details/122014795
版权

文章目录

分布式锁场景和介绍：

分布式锁演进-基本原理
在这里插入图片描述

在这里插入图片描述
分布式锁演进-阶段一
在这里插入图片描述
分布式锁演进-阶段二
在这里插入图片描述
分布式锁演进-阶段三
在这里插入图片描述
分布式锁演进-阶段四
在这里插入图片描述
分布式锁演进-阶段五
在这里插入图片描述

分布式锁一般有如下的特点：

互斥性： 同一时刻只能有一个线程持有锁
可重入性： 同一节点上的同一个线程如果获取了锁之后能够再次获取锁
锁超时：和J.U.C中的锁一样支持锁超时，防止死锁
高性能和高可用： 加锁和解锁需要高效，同时也需要保证高可用，防止分布式锁失效
具备阻塞和非阻塞性：能够及时从阻塞状态中被唤醒

分布式锁模板类：

/**
 * 分布式锁模板类
 * Created by sunyujia@aliyun.com on 2016/2/23.
 */
public interface DistributedLockTemplate {

    /**
     *
     * @param lockId 锁id(对应业务唯一ID)
     * @param timeout 单位毫秒
     * @param callback 回调函数
     * @return
     */
    public Object execute(String lockId,int timeout,Callback callback);
}


public interface DistributedReentrantLock {
    public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException;

    public void unlock();
}

回调接口：

/**
 * Created by sunyujia@aliyun.com on 2016/2/23.
 */
public interface Callback {

    public Object onGetLock() throws InterruptedException;

    public Object onTimeout() throws InterruptedException;
}

锁实现类


/**
 * Created by sunyujia@aliyun.com on 2016/2/26.
 */
public class RedisDistributedLockTemplate implements DistributedLockTemplate {
    private static final org.slf4j.Logger log = LoggerFactory.getLogger(RedisDistributedLockTemplate.class);

    private JedisPool jedisPool;


    public RedisDistributedLockTemplate(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }



    @Override
    public Object execute(String lockId, int timeout, Callback callback) {
        RedisReentrantLock distributedReentrantLock = null;
        boolean getLock=false;
        try {
            distributedReentrantLock = new RedisReentrantLock(jedisPool,lockId);
            if(distributedReentrantLock.tryLock(new Long(timeout), TimeUnit.MILLISECONDS)){
                getLock=true;
                return callback.onGetLock();
            }else{
                return callback.onTimeout();
            }
        }catch(InterruptedException ex){
            log.error(ex.getMessage(), ex);
            Thread.currentThread().interrupt();
        }catch (Exception e) {
            log.error(e.getMessage(), e);
        }finally {
            if(getLock) {
                distributedReentrantLock.unlock();
            }
        }
        return null;
    }
}



/**
 * Created by sunyujia@aliyun.com on 2016/2/26.
 */
public class HHRedisDistributedLockTemplate implements DistributedLockTemplate {
    private static final org.slf4j.Logger log = LoggerFactory.getLogger(HHRedisDistributedLockTemplate.class);

    private JedisPool jedisPool;
    private Jedis jedis ;

    public HHRedisDistributedLockTemplate(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
        this.jedis = jedisPool.getResource();
    }


    public boolean tryLock(String key, String ran, int timout){
        System.out.println("tryLock key:"+key+"ran:"+ran);
        Long val = jedis.setnx(key, ran);
        System.out.println("tryLock key:"+key+"ran:"+ran+"val:"+val);
        jedis.pexpire(key,timout);

        return  jedis.get(key).equals(ran);
    }

    public boolean unLock(String key, String value){
        if (value.equals(jedis.get(key))){
            jedis.del(key);
            System.out.println("unLock key:"+key+"val:"+value);
        }else{
            jedis.close();
            System.out.println("unlockERROR:"+"key:"+key+"expectVal:"+value+"val:"+jedis.get(key));
            return false;
        }
        jedis.close();
        return true;
    }

    @Override
    public Object execute(String lockId, int timeout, Callback callback) {
        String ran = Thread.currentThread().getName();

        boolean getLock=false;
        try {
            if(tryLock(lockId,ran, timeout)){
                getLock=true;
                return callback.onGetLock();
            }else{
                return callback.onTimeout();
            }
        }catch(InterruptedException ex){
            log.error(ex.getMessage(), ex);
            Thread.currentThread().interrupt();
        }catch (Exception e) {
            log.error(e.getMessage(), e);
        }finally {
            if(getLock) {
                unLock(lockId,ran);
            }else{
                jedis.close();
            }
        }
        return null;
    }
}

lua脚本加锁和解锁

class RedisLockInternals {
    private static final org.slf4j.Logger log = LoggerFactory.getLogger(RedisLockInternals.class);

    private JedisPool jedisPool;

    /**
     * 重试等待时间
     */
    private int retryAwait=300;

    private int lockTimeout=2000;


    RedisLockInternals(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    String tryRedisLock(String lockId,long time, TimeUnit unit) {
        final long startMillis = System.currentTimeMillis();
        final Long millisToWait = (unit != null) ? unit.toMillis(time) : null;
        String lockValue=null;
        while (lockValue==null){
            lockValue=createRedisKey(lockId);
            if(lockValue!=null){
                break;
            }
            if(System.currentTimeMillis()-startMillis-retryAwait>millisToWait){
                break;
            }
            LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(retryAwait));
        }
        return lockValue;
    }

    private String createRedisKey(String lockId) {
        Jedis jedis = null;
        boolean broken = false;
        try {
            String value=lockId+randomId(1);
            jedis = jedisPool.getResource();
                        即：
//            - 获取锁（unique_value可以是UUID等）
//            SET resource_name unique_value NX PX 30000
//
//                    - 释放锁（lua脚本中，一定要比较value，防止误解锁）
//            if redis.call("get",KEYS[1]) == ARGV[1] then
//            return redis.call("del",KEYS[1])
//else
//            return 0
//            end
            String luaScript = ""
                    + "\nlocal r = tonumber(redis.call('SETNX', KEYS[1],ARGV[1]));"
                    + "\nredis.call('PEXPIRE',KEYS[1],ARGV[2]);"
                    + "\nreturn r";
            List<String> keys = new ArrayList<String>();
            keys.add(lockId);
            List<String> args = new ArrayList<String>();
            args.add(value);
            args.add(lockTimeout+"");
            Long ret = (Long) jedis.eval(luaScript, keys, args);
            if( new Long(1).equals(ret)){
                return value;
            }
        }finally {
            if(jedis!=null) jedis.close();
        }
        return null;
    }

    void unlockRedisLock(String key,String value) {
        Jedis jedis = null;
        boolean broken = false;
        try {
//String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return
//redis.call('del', KEYS[1]) else return 0 end";
            jedis = jedisPool.getResource();
            String luaScript=""
                    +"\nlocal v = redis.call('GET', KEYS[1]);"
                    +"\nlocal r= 0;"
                    +"\nif v == ARGV[1] then"
                    +"\nr =redis.call('DEL',KEYS[1]);"
                    +"\nend"
                    +"\nreturn r";
            List<String> keys = new ArrayList<String>();
            keys.add(key);
            List<String> args = new ArrayList<String>();
            args.add(value);
            Object r=jedis.eval(luaScript, keys, args);
        } finally {
            if(jedis!=null) jedis.close();
        }
    }

    private final static char[] digits = {'0', '1', '2', '3', '4', '5', '6', '7', '8',
            '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
            'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
            'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
            'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
            'Z'};

    private String randomId(int size) {
        char[] cs = new char[size];
        for (int i = 0; i < cs.length; i++) {
            cs[i] = digits[ThreadLocalRandom.current().nextInt(digits.length)];
        }
        return new String(cs);
    }

    public static void main(String[] args){
        System.out.println(System.currentTimeMillis());
        LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(300));
        System.out.println(System.currentTimeMillis());
    }
}

分布式速度限制

/**
 * 分布式速率限制 例如:限制n秒钟请求x次

 */
public class AccessSpeedLimit {

    private static final org.slf4j.Logger log = LoggerFactory.getLogger(AccessSpeedLimit.class);



    private JedisPool jedisPool;

    public AccessSpeedLimit(){
    }

    public AccessSpeedLimit(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    public JedisPool getJedisPool() {
        return jedisPool;
    }

    public void setJedisPool(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    /**
     * 针对资源key,每seconds秒最多访问maxCount次,超过maxCount次返回false
     *
     * @param key
     * @param seconds
     * @param limitCount
     * @return
     */
    public boolean tryAccess(String key,int seconds,int limitCount){
        LimitRule limitRule=new LimitRule();
        limitRule.setLimitCount(limitCount);
        limitRule.setSeconds(seconds);
        return tryAccess(key,limitRule);
    }

    /**
     * 针对资源key,每limitRule.seconds秒最多访问limitRule.limitCount,超过limitCount次返回false
     * 超过lockCount 锁定lockTime
     * @param key
     * @param limitRule
     * @return
     */
    public boolean tryAccess(String key,LimitRule limitRule){
        String newKey="Limit:"+key;
        Jedis jedis = null;
        boolean broken = false;
        long count=-1;
        try {
            jedis = jedisPool.getResource();
            List<String> keys = new ArrayList<String>();
            keys.add(newKey);
            List<String> args = new ArrayList<String>();
            args.add(Math.max(limitRule.getLimitCount(), limitRule.getLockCount())+"");
            args.add(limitRule.getSeconds()+"");
            args.add(limitRule.getLockCount()+"");
            args.add(limitRule.getLockTime()+"");
            count=Long.parseLong(jedis.eval(buildLuaScript(limitRule),keys,args)+"");
            return count<=limitRule.getLimitCount();
        } finally {
            if(jedis!=null)jedis.close();
        }
    }


    private String buildLuaScript(LimitRule limitRule){
        StringBuilder lua=new StringBuilder();
        lua.append("\nlocal c");
        lua.append("\nc = redis.call('get',KEYS[1])");
        lua.append("\nif c and tonumber(c) > tonumber(ARGV[1]) then");
        lua.append("\nreturn c;");
        lua.append("\nend");
        lua.append("\nc = redis.call('incr',KEYS[1])");
        lua.append("\nif tonumber(c) == 1 then");
        lua.append("\nredis.call('expire',KEYS[1],ARGV[2])");
        lua.append("\nend");
        if(limitRule.enableLimitLock()){
            lua.append("\nif tonumber(c) > tonumber(ARGV[3]) then");
            lua.append("\nredis.call('expire',KEYS[1],ARGV[4])");
            lua.append("\nend");
        }
        lua.append("\nreturn c;");
        return lua.toString();
    }
}

测试分布式锁

public class AccessSpeedLimitTest {
    @Test
    public void test1() throws InterruptedException {
        JedisPool jp=new JedisPool("localhost",6379);
        AccessSpeedLimit accessSpeedLimit=new AccessSpeedLimit(jp);
        SimpleDateFormat sdf=new SimpleDateFormat(" mm:ss");
        while(true){
            //10.0.0.1这个ip每1秒钟最多访问5次if块内代码.
            if(accessSpeedLimit.tryAccess("10.0.0.1", 1,5)){
                System.out.println("yes"+sdf.format(new Date()));
            }else{
                System.out.println("no"+sdf.format(new Date()));
            }
            Thread.sleep(100);
        }
    }

    @Test
    public void test2() throws InterruptedException {
        JedisPool jp=new JedisPool("127.0.0.1",6379);
        final RedisDistributedLockTemplate template=new RedisDistributedLockTemplate(jp);
        LimitRule limitRule=new LimitRule();
        limitRule.setSeconds(1);
        limitRule.setLimitCount(5);
        limitRule.setLockCount(7);
        limitRule.setLockTime(2);
        AccessSpeedLimit accessSpeedLimit=new AccessSpeedLimit(jp);
        SimpleDateFormat sdf=new SimpleDateFormat(" mm:ss");
        while(true){
            //10.0.0.1这个ip每1秒钟最多访问5次if块内代码.1秒超过10次后,锁定2秒,2秒内无法访问.
            if(accessSpeedLimit.tryAccess("10.0.0.1",limitRule)){
                System.out.println("yes"+sdf.format(new Date()));
            }else{
                System.out.println("no"+sdf.format(new Date()));
            }
            Thread.sleep(100);
        }
    }
}

在这里插入图片描述
在这里插入图片描述

march of Time
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis 基本命令
firefly
12-07 2548
基本命令 # 客户端连接服务器 redis-cli -h <address> -p <port> -a <password> # 列出服务器信息 INFO # 查看服务是否允许 PING key # 判断键的存在; 返回存在的键的数量 EXISTS <key1> <key2> # 删除键 DEL <key1> <ke............
架构师-Redis(二)
liulong1010的专栏
01-29 1156
Lua脚本 发布与订阅 Key过期策略 事务 持久化 RDB AOF 事件 文件事件 事件事件
redis 精髓
真是呆子啊的博客
12-13 1282
一、初探 1、简介 Redis是一个由ANSI C语言编写，性能优秀、支持网络、可持久化的内存数据库，并提供多种语言的API，线程安全，常用于做缓存和分布式锁，支持事务、持久化、主从复制、发布订阅、LUA脚本、LRU驱动事件、流水线、多种集群方案。 Redis跟memcached的只支持k-v类型不同，redis常用的类型主要是 String、List、Hash、Set、ZSet 这5种，并...
redis脚本命令执行（redis.call）
落白
07-26 1万+
1、redis-cli命令行中执行： # 调用redis命令设置缓存 # 不传参数 eval "return redis.call('set', 'name1', 'Tom')" 0 # 传入1个值参数 eval "return redis.call('set', 'name2', ARGV[1])" 0 "Tom" # 传入1个键名参数和1个值参数 eval "return redis.call('set', KEYS[1], ARGV[1])" 1 "name3" "Tom" 2、linux命
随手记录4:spring上下文ApplicationContext 两种获取方式和使用获取普通对象和FactoryBean的不同；
weixin_43812522的博客
09-03 493
随手记录4:spring上下文ApplicationContext 获取和使用;简介关于ApplicationContext 获取关于ApplicationContext 使用1.UserService .java2.FactoryBeanConfig .java结论 简介 项目中基本上好多对象都是交给spring管理的; 但是有些静态的工具类中想获取该对象又不能通过 @Autowired直接注入; 或者有些方法里面需要使用到spring托管的对象; 可以通过ApplicationContext 直接获
Redis脚本全解
程序员Forlan的博客
03-23 1697
本文主要介绍我们为什么使用redis脚本，如何正确去使用，怎么保证原子性，具体的应用场景
Redis Template实现分布式锁的实例代码
09-09
Redis 分布式锁是一种在分布式系统中实现锁的常见方法，其核心在于利用Redis的原子性操作来保证并发环境下的安全。在本例中，使用了`Redis Template`，它是Spring Data Redis提供的一个高级API，方便进行Redis的操作...
基于redis和lua脚本的分布式锁的实现
最新发布
01-08
“基于Redis和Lua脚本的分布式锁的实现” 基于Redis和Lua脚本的分布式锁的实现是使用Redis和Lua脚本来实现分布式锁的技术。分布式锁是指在分布式系统中，多个节点之间需要协调和同步的机制，以避免同时访问共享资源...
redis分布式锁.zip
10-18
在实际项目中，为了提高代码的健壮性和可维护性，通常会封装一个 Redis 分布式锁的客户端库，例如 Java 中的 Jedis 或 lettuce 库。这些库提供了更高级别的接口，隐藏了底层的 Redis 操作细节，使开发者更容易地使用...
C#.net Redis分布式锁源码实现
02-27
本篇文章将深入探讨如何在C#.NET环境下利用Redis实现分布式锁，以及相关的核心知识点。 首先，让我们理解什么是分布式锁。分布式锁是在分布式系统中，用于协调不同节点间对共享资源访问的一种工具。它确保在任何...
Redis分布式锁实现Redisson 15问.doc
07-09
Redis分布式锁是指在分布式系统中，多个服务实例之间对同一个资源加锁的机制，以保证数据的一致性和安全性。Redisson是一个基于Redis的分布式锁实现，它提供了一个高效、可靠的加锁机制。在本文中，我们将深入探讨...
分布式锁测试类
越努力越幸运~~ Java领域从业者；CSDN新兴创新博主；Java领域优质创作者；书写奋斗者故事;欢迎交流学习进步；
05-27 727
分布式锁 @Scheduled是加了定时任务，仅为场景使用分布式锁。 1、配置pom文件 <!-- redis分布式锁 --> <dependency> <groupId>com.baomidou</groupId> <artifactId>lock4j-redisson-spring-boot-starter</artifactId> <version>2.2.2</version> &
实战篇Redis(2)
wuzj1314的博客
12-05 559
分布式锁：满足分布式系统或集群模式下多进程可见并且互斥的锁。分布式锁的核心思想就是让大家都使用同一把锁，只要大家使用的是同一把锁，那么我们就能锁住线程，不让线程进行，让程序串行执行，这就是分布式锁的核心思路 那么分布式锁他应该满足一些什么样的条件呢？可见性：多个线程都能看到相同的结果，注意：这个地方说的可见性并不是并发编程中指的内存可见性，只是说多个进程之间都能感知到变化的意思互斥：互斥是分布式锁的最基本的条件，使得程序串行执行高可用：程序不易崩溃，时时刻刻都保证较高的可用性高性能：由于加锁本身就让性能降低
Redis实现分布式锁
weixin_45570824的博客
01-18 1830
Redis实现分布式锁
快速入门Redis调用Lua脚本及使用场景介绍
字母哥博客
02-26 3894
Redis 是一种非常流行的内存数据库，常用于数据缓存与高频数据存储。大多数开发人员可能听说过redis可以运行 Lua 脚本，但是可能不知道redis在什么情况下需要使用到Lua脚本。 一、阅读本文前置条件 可以遵循这个链接中的方法在操作系统上安装 Redis 如果你对redis命令不熟悉，查看《Redis 命令引用》 二、为什么需要Lua脚本 简而言之：Lua脚本带来性能的提升。 很多应用的服务任务包含多步redis操作以及使用多个redis命令，这时你可以使用Redis结合Lua脚本，会为你的
分布式锁的封装框架 - Lock4j 源码分析
2301_76607156的博客
03-30 871
总而言之，Lock4j是一个非常轻量级的分布式锁框架。它并没有从0到1的去实现一个分布式锁，而是灵活使用Springboot、SpringAOP的扩展功能，将常用的分布式锁封装起来，为用户提供一种更加便捷、简单的使用工具。
redis.call() 和 redis.pcall()
热门推荐
坚持住啊
07-15 1万+
下面是来自官方文档的解释： 原文http://www.redis.cn/commands/eval.html redis.call() 和 redis.pcall() 的唯一区别在于它们对错误处理的不同。 当 redis.call() 在执行命令的过程中发生错误时，脚本会停止执行，并返回一个脚本错误，错误的输出信息会说明错误造成的原因： > del foo (integer) 1 > lpush foo a (integer) 1 > eval "return redis.ca.
Redis INCR key
weixin_33800463的博客
10-27 909
2019独角兽企业重金招聘Python工程师标准>>> ...
Redis的Lua脚本和函数
duke_ding2的博客
05-07 1589
环境： 操作系统： Ubuntu 20.04 Redis：7.0.0 我们知道Redis主要用途是数据存储，而可编程性（programmability）意味着用户可以在Redis服务器上运行自定义的脚本，实现自定义逻辑。用户脚本是在Redis的嵌入式沙箱脚本引擎中运行的，也就是Lua解释器。 使用脚本的优点如下： 可编程性：实现自定义的逻辑； 性能：脚本是一次性执行的，节省了与Redis服务器往返交互的开销，另外，对数据的读写都是在服务器端进行了，因此性能非常高效； 原子性：脚本运行是原子的，避免了竞
分布式锁122222222
01-04
分布式锁122222222

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值