自己实现一个分布式锁

已于 2024-09-07 23:09:50 修改
阅读量716 收藏 15
点赞数 6
分类专栏： # 中间件 文章标签： 分布式
于 2024-09-07 10:04:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43783284/article/details/141989802
版权

我的博客大纲

我的后端学习大纲

1.setnx命令：

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

2.基于Redis实现分布式锁：

2.1.基本实现：

借助于redis中的命令setnx(key, value)，key不存在就新增，存在就什么都不做。同时有多个客户端发送setnx命令，只有一个客户端可以成功，返回1（true）；其他的客户端返回0（false）。
在这里插入图片描述
1.多个客户端同时获取锁（setnx）
2.获取成功，执行业务逻辑，执行完成释放锁（del）
3.其他客户端等待重试

2.2.编码实现Redis分布式锁：

  • 1.改造StockService方法：
@Service
public class StockService {

    @Autowired
    private StringRedisTemplate redisTemplate;
    
    public void deduct() {
        // 加锁setnx
        Boolean lock = this.redisTemplate.opsForValue().setIfAbsent("lock", "111");
        // 重试：递归调用
        if (!lock){
            try {
                Thread.sleep(50);
                this.deduct();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            try {
                // 1. 查询库存信息
                String stock = redisTemplate.opsForValue().get("stock").toString();

                // 2. 判断库存是否充足
                if (stock != null && stock.length() != 0) {
                    Integer st = Integer.valueOf(stock);
                    if (st > 0) {
                        // 3.扣减库存
                        redisTemplate.opsForValue().set("stock", String.valueOf(--st));
                    }
                }
            } finally {
                // 解锁
                this.redisTemplate.delete("lock");
            }
        }
    }
}
  • 2.其中，加锁也可以使用循环：
// 加锁，获取锁失败重试
while (!this.redisTemplate.opsForValue().setIfAbsent("lock", "111")){
    try {
        Thread.sleep(40);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
  • 3.解锁：
// 释放锁
this.redisTemplate.delete("lock");
  • 4.使用Jmeter压力测试如下：
    在这里插入图片描述

3、 防死锁：

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

a.死锁及解决办法：

a1.问题：
  • 1.setnx刚刚获取到锁，当前服务器宕机，导致del释放锁无法执行，进而导致锁无法锁无法释放（死锁）
a2.解决办法：
  • 1.解决：给锁设置过期时间，自动释放锁。
a3.设置过期时间两种方式：
  • 1.通过expire设置过期时间（缺乏原子性：如果在setnx和expire之间出现异常，锁也无法释放）
  • 2.使用set指令设置过期时间：set key value ex 3 nx（既达到setnx的效果，又设置了过期时间）
    在这里插入图片描述
  • 3.压力测试肯定也没有问题。

4、防误删

a.问题及解决办法

a1.问题：
  • 1.可能会释放其他服务器的锁。
a2.场景：
  • 1.如果业务逻辑的执行时间是7s。执行流程如下
    • 1 index1业务逻辑没执行完，3秒后锁被自动释放。
    • 2.index2获取到锁，执行业务逻辑，3秒后锁被自动释放。
    • 3.index3获取到锁，执行业务逻辑
    • 4.index1业务逻辑执行完成，开始调用del释放锁，这时释放的是index3的锁，导致index3的业务只执行1s就被别人释放。最终等于没锁的情况。
a3.解决：

  • 1.setnx获取锁时，设置一个指定的唯一值（例如：uuid）；释放前获取这个值，判断是否自己的锁
    在这里插入图片描述

  • 实现如下：
    在这里插入图片描述

问题：删除操作缺乏原子性。

场景：

  1. index1执行删除时，查询到的lock值确实和uuid相等
  2. index1执行删除前，lock刚好过期时间已到，被redis自动释放
  3. index2获取了lock
  4. index1执行删除，此时会把index2的lock删除
  • 解决方案：没有一个命令可以同时做到判断 + 删除，所有只能通过其他方式实现（**LUA脚本**）

6、可重入锁

a.可重入锁使用场景：

  • 1.由于上述加锁命令使用了 SETNX ，一旦键存在就无法再设置成功，这就导致后续同一线程内继续加锁，将会加锁失败。
  • 2.当一个线程执行一段代码成功获取锁之后，继续执行时，又遇到加锁的子任务代码，可重入性就保证线程能继续执行，而不可重入就是需要等待锁释放之后，再次获取锁成功，才能继续往下行。
  • 3.用一段 Java 代码解释可重入：
public synchronized void a() {
    b();
}

public synchronized void b() {
    // pass
}
  • 4.假设 X 线程在 a 方法获取锁之后，继续执行 b 方法，如果此时不可重入，线程就必须等待锁释放，再次争抢锁。锁明明是被 X 线程拥有，却还需要等待自己释放锁，然后再去抢锁，这看起来就很奇怪，我释放我自己
  • 5.可重入性就可以解决这个尴尬的问题，当线程拥有锁之后，往后再遇到加锁方法，直接将加锁次数加 1，然后再执行方法逻辑。退出加锁方法之后，加锁次数再减 1，当加锁次数为 0 时，锁才被真正的释放。
  • 6.可以看到可重入锁最大特性就是计数，计算加锁的次数。所以当可重入锁需要在分布式环境实现时，我们也就需要统计加锁次数。
  • 7.解决方案：redis + Hash

b.锁操作：

b1. 加锁脚本
  • 1.Redis 提供了 Hash （哈希表）这种可以存储键值对数据结构。所以我们可以使用 Redis Hash 存储的锁的重入次数，然后利用 lua 脚本判断逻辑。
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
  • 2.假设值为：KEYS:[lock], ARGV[uuid, expire]
  • 3.如果锁不存在或者这是自己的锁，就通过hincrby（不存在就新增并加1，存在就加1）获取锁或者锁次数加1。
b2. 解锁脚本
-- 判断 hash set 可重入 key 的值是否等于 0
-- 如果为 nil 代表 自己的锁已不存在，在尝试解其他线程的锁，解锁失败
-- 如果为 0 代表 可重入次数被减 1
-- 如果为 1 代表 该可重入 key 解锁成功
if(redis.call('hexists', KEYS[1], ARGV[1]) == 0) then 
    return nil; 
elseif(redis.call('hincrby', KEYS[1], ARGV[1], -1) > 0) then 
    return 0; 
else 
    redis.call('del', KEYS[1]); 
    return 1; 
end;
b3. 代码实现
  • 1.由于加解锁代码量相对较多，这里可以封装成一个工具类：
    在这里插入图片描述
  • DistributedLockClient工厂类具体实现：
@Component
public class DistributedLockClient {

    @Autowired
    private StringRedisTemplate redisTemplate;

    private String uuid;

    public DistributedLockClient() {
        this.uuid = UUID.randomUUID().toString();
    }

    public DistributedRedisLock getRedisLock(String lockName){
        return new DistributedRedisLock(redisTemplate, lockName, uuid);
    }
}
  • DistributedRedisLock实现如下：
public class DistributedRedisLock implements Lock {

    private StringRedisTemplate redisTemplate;

    private String lockName;

    private String uuid;

    private long expire = 30;

    public DistributedRedisLock(StringRedisTemplate redisTemplate, String lockName, String uuid) {
        this.redisTemplate = redisTemplate;
        this.lockName = lockName;
        this.uuid = uuid;
    }

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

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

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

    /**
     * 加锁方法
     * @param time
     * @param unit
     * @return
     * @throws InterruptedException
     */
    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        if (time != -1){
            this.expire = unit.toSeconds(time);
        }
        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 (!this.redisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(lockName), getId(), String.valueOf(expire))){
            Thread.sleep(50);
        }
        return true;
    }

    /**
     * 解锁方法
     */
    @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 " +
                "   return redis.call('del', KEYS[1]) " +
                "else " +
                "   return 0 " +
                "end";
        Long flag = this.redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList(lockName), getId());
        if (flag == null){
            throw new IllegalMonitorStateException("this lock doesn't belong to you!");
        }
    }

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

    /**
     * 给线程拼接唯一标识
     * @return
     */
    String getId(){
        return uuid + ":" + Thread.currentThread().getId();
    }
}
b4. 使用及测试
  • 1.在业务代码中使用：
public void deduct() {
    DistributedRedisLock redisLock = this.distributedLockClient.getRedisLock("lock");
    redisLock.lock();

    try {
        // 1. 查询库存信息
        String stock = redisTemplate.opsForValue().get("stock").toString();

        // 2. 判断库存是否充足
        if (stock != null && stock.length() != 0) {
            Integer st = Integer.valueOf(stock);
            if (st > 0) {
                // 3.扣减库存
                redisTemplate.opsForValue().set("stock", String.valueOf(--st));
            }
        }
    } finally {
        redisLock.unlock();
    }
}
  • 2.测试：
    在这里插入图片描述
  • 3.测试可重入性：
    在这里插入图片描述

7、自动续期

  • 1.lua脚本：
if(redis.call('hexists', KEYS[1], ARGV[1]) == 1) then 
    redis.call('expire', KEYS[1], ARGV[2]); 
    return 1; 
else 
    return 0; 
end
  • 2.在RedisDistributeLock中添加renewExpire方法：
public class DistributedRedisLock implements Lock {

    private StringRedisTemplate redisTemplate;

    private String lockName;

    private String uuid;

    private long expire = 30;

    public DistributedRedisLock(StringRedisTemplate redisTemplate, String lockName, String uuid) {
        this.redisTemplate = redisTemplate;
        this.lockName = lockName;
        this.uuid = uuid + ":" + Thread.currentThread().getId();
    }

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

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

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

    /**
     * 加锁方法
     * @param time
     * @param unit
     * @return
     * @throws InterruptedException
     */
    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        if (time != -1){
            this.expire = unit.toSeconds(time);
        }
        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 (!this.redisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(lockName), uuid, String.valueOf(expire))){
            Thread.sleep(50);
        }
        // 加锁成功，返回之前，开启定时器自动续期
        this.renewExpire();
        return true;
    }

    /**
     * 解锁方法
     */
    @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 " +
                "   return redis.call('del', KEYS[1]) " +
                "else " +
                "   return 0 " +
                "end";
        Long flag = this.redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList(lockName), uuid);
        if (flag == null){
            throw new IllegalMonitorStateException("this lock doesn't belong to you!");
        }
    }

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

    // String getId(){
    //     return this.uuid + ":" + Thread.currentThread().getId();
    // }

    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 (redisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(lockName), uuid, String.valueOf(expire))) {
                    renewExpire();
                }
            }
        }, this.expire * 1000 / 3);
    }
}
  • 3.在tryLock方法中使用：
    在这里插入图片描述
  • 4.构造方法作如下修改：
    在这里插入图片描述
  • 5.解锁方法作如下修改：
    在这里插入图片描述

8、手写分步式锁小结

a.特征：

  • 1.独占排他：setnx
  • 2.防死锁：
    • redis客户端程序获取到锁之后，立马宕机。给锁添加过期时间
    • 不可重入：可重入
  • 3.防误删：先判断是否自己的锁才能删除
  • 4.原子性：
    • 加锁和过期时间之间：set k v ex 3 nx
    • 判断和释放锁之间：lua脚本
  • 5.可重入性：hash（key field value） + lua脚本
  • 6.自动续期：Timer定时器 + lua脚本
  • 7.在集群情况下，导致锁机制失效：
    • 客户端程序10010，从主中获取锁
    • 从还没来得及同步数据，主挂了
    • 于是从升级为主
    • 客户端程序10086就从新主中获取到锁，导致锁机制失效

b.锁操作：

b1.加锁：
  • 1.setnx：独占排他 死锁、不可重入、原子性
  • 2.set k v ex 30 nx：独占排他、死锁 不可重入
  • 3.hash + lua脚本：可重入锁
    • 判断锁是否被占用（exists），如果没有被占用则直接获取锁（hset/hincrby）并设置过期时间（expire）
    • 如果锁被占用，则判断是否当前线程占用的（hexists），如果是则重入（hincrby）并重置过期时间（expire）
    • 否则获取锁失败，将来代码中重试
  • 4.Timer定时器 + lua脚本：实现锁的自动续期
    • 判断锁是否自己的锁（hexists == 1），如果是自己的锁则执行expire重置过期时间
b2.解锁
  • 1.del：导致误删
  • 2.先判断再删除同时保证原子性：lua脚本
  • 3.hash + lua脚本：可重入
    • 判断当前线程的锁是否存在，不存在则返回nil，将来抛出异常
    • 存在则直接减1（hincrby -1），判断减1后的值是否为0，为0则释放锁（del），并返回1
    • 不为0，则返回0
b3.重试：
  • 1.递归 循环

40.9. 红锁算法

a.redis集群状态下的问题：

  1. 客户端A从master获取到锁
  2. 在master将锁同步到slave之前，master宕掉了。
  3. slave节点被晋级为master节点
  4. 客户端B取得了同一个资源被客户端A已经获取到的另外一个锁。

b.安全失效:

b1.概述：
  • 1.解决集群下锁失效，参照redis官方网站针对redlock文档：https://redis.io/topics/distlock
  • 2.在算法的分布式版本中，我们假设有N个Redis服务器。这些节点是完全独立的，因此我们不使用复制或任何其他隐式协调系统。**前几节已经描述了如何在单个实例中安全地获取和释放锁，在分布式锁算法中，将使用相同的方法在单个实例中获取和释放锁。**将N设置为5是一个合理的值，因此需要在不同的计算机或虚拟机上运行5个Redis主服务器，确保它们以独立的方式发生故障。
b2.为了获取锁，客户端执行以下操作：
  • 1.客户端以毫秒为单位获取当前时间的时间戳，作为起始时间。
  • 2.客户端尝试在所有N个实例中顺序使用相同的键名、相同的随机值来获取锁定。每个实例尝试获取锁都需要时间，客户端应该设置一个远小于总锁定时间的超时时间。例如，如果自动释放时间为10秒，则尝试获取锁的超时时间可能在5到50毫秒之间。这样可以防止客户端长时间与处于故障状态的Redis节点进行通信：如果某个实例不可用，尽快尝试与下一个实例进行通信。
  • 3.客户端获取当前时间 减去在步骤1中获得的起始时间，来计算获取锁所花费的时间。当且仅当客户端能够在大多数实例（至少3个）中获取锁时，并且获取锁所花费的总时间小于锁有效时间，则认为已获取锁。
  • 4.如果获取了锁，则将锁有效时间减去 获取锁所花费的时间，如步骤3中所计算。
  • 5.如果客户端由于某种原因（无法锁定N / 2 + 1个实例或有效时间为负）而未能获得该锁，它将尝试解锁所有实例（即使没有锁定成功的实例）
b3.总结：
  • 1.每台计算机都有一个本地时钟，我们通常可以依靠不同的计算机来产生很小的时钟漂移。只有在拥有锁的客户端将在锁有效时间内（如步骤3中获得的）减去一段时间（仅几毫秒）的情况下终止工作，才能保证这一点。以补偿进程之间的时钟漂移
  • 2.当客户端无法获取锁时，它应该在随机延迟后重试，以避免同时获取同一资源的多个客户端之间不同步（这可能会导致脑裂的情况：没人胜）。同样，客户端在大多数Redis实例中尝试获取锁的速度越快，出现裂脑情况（以及需要重试）的窗口就越小，因此理想情况下，客户端应尝试将SET命令发送到N个实例同时使用多路复用。
  • 3.值得强调的是，对于未能获得大多数锁的客户端，尽快释放（部分）获得的锁有多么重要，这样就不必等待锁定期满才能再次获得锁（但是，如果发生了网络分区，并且客户端不再能够与Redis实例进行通信，则在等待密钥到期时需要付出可用性损失）。
1.01^1000
关注
  • 6
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java redis evalsha_RedisTemplate 执行lua脚本出错
weixin_29417899的博客
02-24 1068
使用lua脚本释放锁时，lua 脚本中返回值为int时出现异常，但是将返回值修改为string时却能正常使用错误信息如下：org.springframework.data.redis.RedisSystemException: Redis exception; nested exception is io.lettuce.core.RedisException: java.lang.Illegal...
java redis evalsha_高并发 共享资源 死锁 分布式锁 redisTemplate实现分布式锁 EvalSha is not supported in cluster environm...
weixin_36297381的博客
02-24 543
也有不用回调函数直接调用脚本的版本，但是经过我的测试之后，发现报错EvalSha is not supported in cluster environment上锁解锁的代码比较简单，也好理解。利用lua脚本解释redis命令，保证命令一次性运行成功，从而保证命令执行的原子性。但是想和业务系统结合起来还是有难度的。特别是在本地事务中去使用的时候，需要结合业务特点，本地事务提交之后解锁也要成功。/*...
第二章_基于redis实现分布式锁
sinat_31583645的博客
06-15 914
大家都知道，如果负责储存这个分布式锁的Redisson节点宕机以后，而且这个锁正好处于锁住的状态时，这个锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。值得强调的是，对于未能获得大多数锁的客户端，尽快释放（部分）获得的锁有多么重要，这样就不必等待锁定期满才能再次获得锁（但是，如果发生了网络分区，并且客户端不再能够与Redis实例进行通信，则在等待密钥到期时需要付出可用性损失）。
redis的eval命令，Java工作经验6年
最新发布
m0_61549984的博客
03-28 640
针对以上面试题，小编已经把面试题+答案整理好了。
Redis学习笔记(七)：Redis中Lua语言应用和原子性控制
IT-CRUD
03-15 1205
Lua脚本在Redis里面使用的范围还是很广的，如从数据库中批量将数据导入到Redis中、分布式锁防止锁误删、多操作原子性要求等，这些都会用到Lua脚本。但是这里还是需要注意的是Lua只能保证原子性，不能保证事务性。另外根据对Redis的了解，其本身是提供事务机制的，但是这个事务机制在很多情况是不能回滚的（鸡肋），所以用起来也更少。这里不说具体的事务性，而是来一起看看Lua脚本实现原子操作。 Lua 概念 Lua 是一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放， 其设计目的是为了嵌入应用程序中
使用MySQL实现一个分布式锁
09-08
以下是如何使用MySQL实现分布式锁的一个简单示例： 1. **尝试获取锁**：通过`tryLock`方法尝试获取锁。在`GlobalLockComponent`类中，调用`tryLockUtil`的`tryLock`方法，传入数据库操作接口`globalLockDAO`和需要...
详解ASP.Net Core 中如何借助CSRedis实现一个安全高效的分布式锁
10-17
首先，我们需要了解Redis中用于实现分布式锁的一些基本命令： 1. **Setnx命令**：`SETNX key value`，此命令只有在键key不存在时才会设置其值为value，返回1表示设置成功，0表示key已存在。 2. **Getset命令**：`...
Redis实现分布式锁(附源码+讲义)
07-01
分布式锁有很多种解决方案，今天我们要讲的是怎么使用缓存数据库Redis来实现分布式锁。 课程目标:  理解redis分布式锁的应用场景  掌握redis分布式锁的实现原理  掌握redis分布式锁在微服务项目中的应用  掌握...
分布式锁三种实现方式及对比
12-14
1. **基于数据库实现分布式锁** - **悲观锁**：使用`SELECT ... WHERE ... FOR UPDATE`语句实现，可以实现行级锁定，确保同一时刻只有一个事务能修改特定数据。但需要注意，`WHERE`条件中的字段必须有索引，否则...
Lua 脚本在redis中的入门使用——eval
猎人在吃肉
03-17 5279
EVAL script numkeys key [key …] arg [arg …] 1、 script 参数是一段 Lua 5.1 脚本程序，它会被运行在 Redis 服务器上下文中，这段脚本不必(也不应该)定义为一个 Lua 函数。 2、numkeys 参数用于指定键名的个数。 3、键名 key [key ...] 键名参数。从 eval 的第三个参数开始算起，表示在脚本中所用到...
java redis evalsha_Redis Evalsha 命令
weixin_33430573的博客
02-24 402
Redis Evalsha 命令Redis Evalsha 命令根据给定的 sha1 校验码，执行缓存在服务器中的脚本。将脚本缓存到服务器的操作可以通过 SCRIPT LOAD 命令进行。这个命令的其他地方，比如参数的传入方式，都和 EVAL 命令一样。语法redis Evalsha 命令基本语法如下：redis127.0.0.1:6379>EVALSHAsha1numkeyske...
利用redis + lua解决抢红包高并发的问题
热门推荐
横云断岭的专栏
02-20 13万+
抢红包的需求分析 抢红包的场景有点像秒杀，但是要比秒杀简单点。 因为秒杀通常要和库存相关。而抢红包则可以允许有些红包没有被抢到，因为发红包的人不会有损失，没抢完的钱再退回给发红包的人即可。 另外像小米这样的抢购也要比淘宝的要简单，也是因为像小米这样是一个公司的，如果有少量没有抢到，则下次再抢，人工修复下数据是很简单的事。而像淘宝这么多商品，要是每一个都存在着修复数据的风险，那如果出故障了则很麻烦...
RedisTemplate执行lua脚本，集群模式下报错解决
u012899746的博客
11-21 1万+
  redis集群配置： 在使用spring的RedisTemplate执行lua脚本时，报错EvalSha is not supported in cluster environment，不支持cluster。 代码： @Test public void test4() throws Exception { DefaultRedisScript sc...
redis的eval命令
wusuopuBUPT的专栏
04-20 4510
EVAL 和 EVALSHA 命令是从 Redis 2.6.0 版本开始的，使用内置的 Lua 解释器，可以对 Lua 脚本进行求值。 -------- redis下载： 包括linux和windows版本： http://redis.io/download
redis eval 实现限流
06-03 432
大致流程: 每次请求就写入有序集合里面，集合的sorce值是当前毫秒时间戳（防止秒出现重复），可以认为每一次请求就一个时间戳在里面。 从集合里面去掉10分钟以前所有的集合数据。然后计算出当前的集合里面数量 根据这个数量来与我们阈值做大小判断，如果超过就锁住，否则继续走下去 //将我们时间戳写入我们redis的有序集合里面 Redis::zadd('user:1:request:nums',1561456435,'1561456435.122'); //设置key的过期时间为
redis中的事务、lua脚本和管道的使用场景
fangjian1204的专栏
01-26 1万+
事务redis中的事务并不像mysql中那么完美，只是简单的保证了原子性。redis中提供了四个命令来实现事务，MULTI：类似于mysql中的BEGIN;EXEC：类似于COMMIT;DISCARD类似于ROLLBACK;WATCH则是用于来实现mysql中类似锁的功能。具体的使用方法非常简单，例如：127.0.0.1:6379> multi OK 127.0.0.1:6379> incr cou
【Lua】简述Redis中lua脚本的EVAL命令
不想睡觉的橘子君的博客
11-28 962
如果你是基于Redis插入Lua脚本，则只需要一些简单的Lua脚本知识，就可以初步的应用lua。通过Lua脚本，我们可以原子性的去处理一些单条redis命令无法完成的一系列操作[1]。OK，关于eval的简述就写到这里。有的时候学习就是这样，别想着一下子就全都学会，就需要啥就去学啥，慢慢的很多东西就都能掌握了…理解了上面的EVAL命令，就能够很简单的理解jedis.eval()方法及其参数的意思了。最先需要认识的，就是EVAL命令，通过它，我们可以执行redis的命令。
Java实现一个分布式锁
09-23
我可以为你提供一些有关如何使用Java实现分布式锁的信息。首先，您可以使用Java中的锁定机制，例如java.util.concurrent.locks.Lock，来实现分布式锁。其次，您可以使用分布式系统中常见的分布式编程模式，例如Two-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值