Redis入门(五)之分布式锁

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

1.写在前面

Redis上篇博客讲了下集群的搭建，我们只知道Redis的集群中有16384个插槽，当我们录入一个值的时候，先对这个键进行hash的算法然后，然后对这个hash出来的数，进行取余，然后就得到一个0~16384中间的某个值，然后根据这个值找到对应的机器，将值写入到对应的Redis服务上，我们都知道Redis的客户端提供了一个重定向的功能，但是我们在java中使用jedis如何操作呢？这就是我们今天的博客的一部分的内容，同时会带大家写一个Redis的分布式的锁。

2.Redis集群下，Jedis如何录入数据？

我们首先来看下Redis集群下录入数据的原理吧！具体的如下：

在这里插入图片描述

从上面的示意图，我们可以一个key需要通过Redis的计算，才能知道插入那个机器上去，而Jedis刚开始是不知道，那么该怎么办呢？而重定向的功能只有Redis的客户端可以的。于是我们想出了一个方案：就是根据这些槽位进行对应的连接池的映射，然后录入的数据的时候，我们先计算出来这个key在哪个槽位 中，然后从Map的映射中，取出这个连接池，这样就不会出错了，而Jedis就是这样做，具体的流程如下：

在这里插入图片描述

思路和我说的差不多，那么我们怎么证明我们的思路是对的，那么当然需要我们去写代码去证明去了，具体的代码如下：

import redis.clients.jedis.*;

import java.util.*;

public class TestRedisCluster {

    public static void main(String[] args) {
      	Set<HostAndPort> nodesList = new HashSet<>();
        nodesList.add(new HostAndPort("192.168.181.6", 7000));
        nodesList.add(new HostAndPort("192.168.181.6", 7001));
        nodesList.add(new HostAndPort("192.168.181.6", 7002));
        nodesList.add(new HostAndPort("192.168.181.6", 7003));
        nodesList.add(new HostAndPort("192.168.181.6", 7004));
        nodesList.add(new HostAndPort("192.168.181.6", 7005));

        // Jedis连接池配置
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 最大空闲连接数, 默认8个
        jedisPoolConfig.setMaxIdle(200);
        // 最大连接数, 默认8个
        jedisPoolConfig.setMaxTotal(1000);
        //最小空闲连接数, 默认0
        jedisPoolConfig.setMinIdle(100);
        // 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
        jedisPoolConfig.setMaxWaitMillis(3000); // 设置2秒
        //对拿到的connection进行validateObject校验
        jedisPoolConfig.setTestOnBorrow(false);

        JedisCluster jedisCluster = new JedisCluster(nodesList, 2000, 2000, 5, "123456", jedisPoolConfig);
        Map<String, JedisPool> clusterNodes = jedisCluster.getClusterNodes();
        clusterNodes.entrySet().forEach(System.out::println);
    }
}

运行的结果如下：

在这里插入图片描述

可以为我们的每一个节点分配了一个JedisPool,当然还有一个map,存的是键值对是槽位和JedisPool,下面这部分的代码是从源码中拷贝出来，就不放上来了，大家可以看下运行结果，具体的如下：

在这里插入图片描述

从上面的运行的结果，我们可以得出如果槽位在一台Redis服务上，那么它的JedisPool的对象是一样的。那么我们来测试下我们写的代码吧，看看能不能添加东西到Redis的集群中，具体的代码如下：

import com.google.common.collect.Lists;
import com.ys.redis.MyRedisCluster;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.*;
import redis.clients.jedis.util.JedisClusterCRC16;

import java.util.*;

public class TestRedisCluster {

    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(TestRedisCluster.class);
        Set<HostAndPort> nodesList = new HashSet<>();
        nodesList.add(new HostAndPort("192.168.181.6", 7000));
        nodesList.add(new HostAndPort("192.168.181.6", 7001));
        nodesList.add(new HostAndPort("192.168.181.6", 7002));
        nodesList.add(new HostAndPort("192.168.181.6", 7003));
        nodesList.add(new HostAndPort("192.168.181.6", 7004));
        nodesList.add(new HostAndPort("192.168.181.6", 7005));


        // Jedis连接池配置
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 最大空闲连接数, 默认8个
        jedisPoolConfig.setMaxIdle(200);
        // 最大连接数, 默认8个
        jedisPoolConfig.setMaxTotal(1000);
        //最小空闲连接数, 默认0
        jedisPoolConfig.setMinIdle(100);
        // 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
        jedisPoolConfig.setMaxWaitMillis(3000); // 设置2秒
        //对拿到的connection进行validateObject校验
        jedisPoolConfig.setTestOnBorrow(false);

        JedisCluster jedisCluster = new JedisCluster(nodesList, 2000, 2000, 5, "123456", jedisPoolConfig);
        Map<String, JedisPool> clusterNodes = jedisCluster.getClusterNodes();
        clusterNodes.entrySet().forEach(System.out::println);
        while (true) {
            try {
                String s = UUID.randomUUID().toString();
                jedisCluster.set("k" + s, "v" + s);
                System.out.println(jedisCluster.get("k" + s));
                Thread.sleep(1000);
            }catch (Exception e) {
                logger.error(e.getMessage());
            }
        }
    }
}

运行的结果如下：

在这里插入图片描述

发现我们的循环写是没有问题，那么问题来了，如果我们是调用mset这种一次写入多个键的，能不能成功呢？因为我们知道是先计算key的slot,然后再写入，那么从理论上来说，是可以实现，而且也不是很复杂，我们来测试一下，具体的如下：

import com.google.common.collect.Lists;
import com.ys.redis.MyRedisCluster;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.*;
import redis.clients.jedis.util.JedisClusterCRC16;

import java.util.*;

public class TestRedisCluster {

    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(TestRedisCluster.class);
        Set<HostAndPort> nodesList = new HashSet<>();
        nodesList.add(new HostAndPort("192.168.181.6", 7000));
        nodesList.add(new HostAndPort("192.168.181.6", 7001));
        nodesList.add(new HostAndPort("192.168.181.6", 7002));
        nodesList.add(new HostAndPort("192.168.181.6", 7003));
        nodesList.add(new HostAndPort("192.168.181.6", 7004));
        nodesList.add(new HostAndPort("192.168.181.6", 7005));


        // Jedis连接池配置
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 最大空闲连接数, 默认8个
        jedisPoolConfig.setMaxIdle(200);
        // 最大连接数, 默认8个
        jedisPoolConfig.setMaxTotal(1000);
        //最小空闲连接数, 默认0
        jedisPoolConfig.setMinIdle(100);
        // 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
        jedisPoolConfig.setMaxWaitMillis(3000); // 设置2秒
        //对拿到的connection进行validateObject校验
        jedisPoolConfig.setTestOnBorrow(false);

        JedisCluster jedisCluster = new JedisCluster(nodesList, 2000, 2000, 5, "123456", jedisPoolConfig);
        System.out.println(jedisCluster.mset("k1", "v1", "k2", "v2", "k3", "v3"));
    }
}

运行的结果如下：

在这里插入图片描述

可以发现出错了，出错的原因是：无法将此命令分派到 Redis 集群，因为键具有不同的插槽。那么怎么办？这个时候我只有重写，具体的代码如下：

public class MyRedisCluster extends JedisCluster {

    public MyRedisCluster(Set node, int connectionTimeout, int soTimeout, int maxAttempts, String password, GenericObjectPoolConfig poolConfig) {
        super(node, connectionTimeout, soTimeout, maxAttempts, password, poolConfig);
    }

    @Override
    public String mset(String... keyValues) {
        for (int i = 0; i < keyValues.length; i++) {
            if (i % 2 == 0) {
                int slot = JedisClusterCRC16.getCRC16(keyValues[i]) % 16384;
                Jedis connectionFromSlot = this.getConnectionFromSlot(slot);
                System.out.println(keyValues[i] + "---" + keyValues[i + 1]);
                System.out.println(connectionFromSlot.set(keyValues[i], keyValues[i + 1]));
                connectionFromSlot.close();
            }
        }
        return "OK";
    }
}

上面的代码就是先计算这个键的slot，然后获取对应Jedis客户端，然后就可以设置对应的值。我们再来测试一下，具体的代码的如下：

import com.google.common.collect.Lists;
import com.ys.redis.MyRedisCluster;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.*;
import redis.clients.jedis.util.JedisClusterCRC16;

import java.util.*;

public class TestRedisCluster {

    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(TestRedisCluster.class);
        Set<HostAndPort> nodesList = new HashSet<>();
        nodesList.add(new HostAndPort("192.168.181.6", 7000));
        nodesList.add(new HostAndPort("192.168.181.6", 7001));
        nodesList.add(new HostAndPort("192.168.181.6", 7002));
        nodesList.add(new HostAndPort("192.168.181.6", 7003));
        nodesList.add(new HostAndPort("192.168.181.6", 7004));
        nodesList.add(new HostAndPort("192.168.181.6", 7005));

        // Jedis连接池配置
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 最大空闲连接数, 默认8个
        jedisPoolConfig.setMaxIdle(200);
        // 最大连接数, 默认8个
        jedisPoolConfig.setMaxTotal(1000);
        //最小空闲连接数, 默认0
        jedisPoolConfig.setMinIdle(100);
        // 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
        jedisPoolConfig.setMaxWaitMillis(3000); // 设置2秒
        //对拿到的connection进行validateObject校验
        jedisPoolConfig.setTestOnBorrow(false);
        MyRedisCluster redisCluster = new MyRedisCluster(nodesList, 2000, 2000, 5, "123456", jedisPoolConfig);
        System.out.println(redisCluster.mset("k1", "v1", "k2", "v2", "k3", "v3"));
    }
}

运行的结果如下：

在这里插入图片描述

发现我们这儿就重写完成了。这个时候我们需要讲我们的Redis的分布式锁了。

3.Redis分布式锁

随着业务的复杂，传统的单体的项目已经无法满足我们现在的需求了，所以我们需要上分布式了，所以传统的jvm锁已经无法满足我们的需求了，需要有新的方案，那么有什么方案呢？既然原来的多台机器多台部署，所以加锁的时候无法是同一把锁，这个时候我们需要上升一个维度，就是找一个公用的地方，进行加锁，这样就不会有问题了，于是我们想到了Redis，那么用Redis，怎么实现加锁呢？首先我们需要了解几个命令，具体的如下：

setex 键 秒值 真实值    设置带过期时间的key，动态设置。

setnx  key   value    只有在 key 不存在时设置 key 的值。

我们可以用上面的API实现对应的加锁的设置，具体的如下图：

在这里插入图片描述

这个图看着似乎很完美，但是似乎有个很大的问题，就是如果线程A抢到了锁，然后执行下单操作的时候，直接崩了，这个时候锁也释放不了，这个时候就会造成死锁的现象了，其他的线程永远拿不到锁，线程A的下单操作也执行不下去。于是我们想到的第二版的解决方案，就是加一个过期时间，于是有了下面的图。

在这里插入图片描述

这个图似乎也没有啥问题，但是如果下单的操作的时间过长，那么这个时候这个lock的键失效了，那么这个时候线程B抢到的锁，然后线程A执行完了，意味着释放锁的时候del lock 释放的是线程B的锁，这样可不行，于是我们又改版。于是有了第三版，具体的如下：

在这里插入图片描述

这儿似乎没有问题，但是又有问题来了，如果我们的业务时间过长的话，大于lock过期的时间，这样同一时间段，就有多个线程来操作这个下单操作了，有人可能说，我把这个时间设置长一点，不就行了嘛！这样就不会导致多个线程加锁成功了，但是这样效率就变低了，所以这种方法似乎也是不行的，于是有了第四版，具体的如下：

在这里插入图片描述

第四版似乎很完美了，但是万一请求多，Redis直接挂了，似乎我们程序就直接崩了，现在全要高可用，所以这儿我们可以用多台Redis，组成一个集群，这样问题就会小很多，于是我们有了第五版的，具体的如下：

在这里插入图片描述

其实上面的几个版本的Redis分布式锁，有个框架叫redission已经帮我们实现了，但是我们今天不打算讲这个，我们要实现一个分布式锁，用第四版的方案实现，先定义我们的接口类，具体的代码如下：

package com.ys;

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

public interface Lock {
    void lock();

    void lockInterruptibly() throws InterruptedException;

    boolean tryLock();

    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    void unlock() throws Exception;

    Condition newCondition();
}

我们这儿只定义了两个方法，真正的锁有很多的方法，但是由于篇幅的原因，所以我这儿就定义常用的两个方法，然后实现这个类，具体的如下：

package com.ys;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.params.SetParams;

import java.util.*;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Condition;


@Component
public class RedisLock implements Lock {

    @Autowired
    private JedisPool jedisPool;

    private static final String key = "lock";

    private ThreadLocal<String> threadLocal = new ThreadLocal<>();

    private static AtomicBoolean isHappened = new AtomicBoolean(true);

    //加锁
    @Override
    public void lock() {
        boolean b = tryLock();  //尝试加锁
        if (b) {
            //拿到了锁 直接返回
            return;
        }
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
      //一直递归到获取到锁
        lock();
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    //尝试加锁
    @Override
    public boolean tryLock() {
      //原子操作
        SetParams setParams = new SetParams();
        setParams.ex(2);  //2s
        setParams.nx();
        String s = UUID.randomUUID().toString();
        Jedis resource = jedisPool.getResource();
        String lock = resource.set(key, s, setParams);
        resource.close();
        if ("OK".equals(lock)) {
            //拿到了锁
            threadLocal.set(s);
            if (isHappened.get()) {
              //设置守护线程
                ThreadUtil.newThread(new MyRunnable(jedisPool)).start();
                isHappened.set(false);
            }
            return true;
        }
        return false;
    }


    static class MyRunnable implements Runnable {

        private JedisPool jedisPool;

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

        @Override
        public void run() {
            Jedis jedis = jedisPool.getResource();
            while (true) {
             	//获取过期时间
                Long ttl = jedis.ttl(key);
              //给过期时间加上1
                if (ttl != null && ttl > 0) {
                    jedis.expire(key, (int) (ttl + 1));
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }


    //第一步判断设置时候的value 和 此时redis的value是否相同
    //解锁
    @Override
    public void unlock() throws Exception {
        String script = "if redis.call(\"get\",KEYS[1])==ARGV[1] then\n" +
                "    return redis.call(\"del\",KEYS[1])\n" +
                "else\n" +
                "    return 0\n" +
                "end";

        Jedis resource = jedisPool.getResource();
      //比较key和值一样的，才删除
        Object eval = resource.eval(script, Arrays.asList(key), Arrays.asList(threadLocal.get()));
        if (Integer.parseInt(eval.toString()) == 0) {
            resource.close();
            throw new Exception("解锁失败");
        }
        resource.close();
    }

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

}

再来看这个工具类ThreadUtil,具体的如下：

package com.ys;

public class ThreadUtil {

    public static volatile Thread thread;

    public static Thread newThread(Runnable runnable){
        if (thread==null){
            synchronized (ThreadUtil.class){
                if(thread==null){
                    thread = new Thread(runnable);
                  //设置为守护线程
                    thread.setDaemon(true);
                }
                return thread;
            }
        }
        return thread;
    }
}

测试类如下：

package com.ys;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.redisson.Redisson;
import org.redisson.RedissonMultiLock;
import org.redisson.RedissonRedLock;
import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.SetParams;

import java.util.UUID;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=SpringConfig.class)
public class Dome {

    private int count=10;

    @Autowired
    @Qualifier("redisLock")
    private com.ys.Lock lock;


    @Test
    public void Test() throws InterruptedException {
        TicketsRunBle ticketsRunBle=new TicketsRunBle();
        Thread thread1=new Thread(ticketsRunBle,"窗口1");
        Thread thread2=new Thread(ticketsRunBle,"窗口2");
        Thread thread3=new Thread(ticketsRunBle,"窗口3");
        Thread thread4=new Thread(ticketsRunBle,"窗口4");
        Thread thread5=new Thread(ticketsRunBle,"窗口5");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
        Thread.currentThread().join();
    }


    public class TicketsRunBle implements Runnable{

        @Override
        public void run() {
            while (count>0){
                lock.lock();
                try {
                    if(count>0){
                      //业务处理的时间大于超时的时间
                        Thread.sleep(ThreadLocalRandom.current().nextInt(2000, 3000));
                        System.out.println(Thread.currentThread().getName()+"售出第"+count--+"张票");
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    try {
                        lock.unlock();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

运行的结果如下：

在这里插入图片描述

可以发现我们的第4版的Redis分布式锁实现完成。

4.写在最后

本篇博客主要介绍Redis的分布式锁和在Redis集群下，Jedis如何录入数据。

了不起的盖茨比。
关注
专栏目录
Redis分布式锁Redisson
梵高
08-23 621
原理：利用setnx的互斥性；释放锁时判断线程标示 缺陷：不可重入、无法重试、锁超时失效。原理：利用hash结构，记录线程标示和重入次数；利用watchDog延续锁时间；利用信号量控制锁重试等待。分布式锁：满足分布式系统或集群模式下多进程可见并且互斥的锁。在释放锁时先获取锁中的线程标示，判断是否与当前线程标示一致。在获取锁时存入线程标示（可以用UUID表示）缺陷：redis宕机引起锁失效问题。互斥：确保只能有一个线程获取锁。如果不一致则不释放锁。
《大厂高并发分布式锁从入门到实战》第2讲之redis分布式锁
小米吃辣椒的博客
09-06 717
上一讲中，我们了解了分布式锁的背景以及jvm锁失效的场景，mysql数据库锁来解决超卖问题，这一讲我们将会学习redis的超卖问题，以及解决方案。 --- 《大厂高并发分布式锁从入门到实战》之redis分布式锁
redis分布式锁工具类
09-26
现在很多项目单机版已经不满足了，分布式变得越受欢迎，同时也带来很多问题，分布式锁也变得没那么容易实现，分享一个redis分布式锁工具类，里面的加锁采用lua脚本（脚本比较简单，采用java代码实现，无须外部调用脚本），项目中都是采用此工具类加锁的，比较实用
redis分布式锁学习
weixin_45222638的博客
09-10 327
redis分布式锁学习
5.Redis分布式锁
zuishengmengsi1990的专栏
09-08 197
这篇文章我想和你聊一聊，关于 Redis 分布式锁的「安全性」问题。 Redis 分布式锁的话题，很多文章已经写烂了，我为什么还要写这篇文章呢？ 因为我发现网上 99% 的文章，并没有把这个问题真正讲清楚。导致很多读者看了很多文章，依旧云里雾里。例如下面这些问题，你能清晰地回答上来吗？ 基于 Redis 如何实现一个分布式锁？ Redis 分布式锁真的安全吗？ Redis 的 Redlock 有什么问题？一定安全吗？ 业界争论 Redlock，到底在争论什么？哪种观点
Redis分布式锁
kutianya518的博客
12-12 379
使用方式:在你项目的类中通过@Resource,注入RedisLockUtil类，然后调用如下所示： @Scheduled(cron = "0 0/30 * * * ?") public void statisticDayLive() { boolean lock = redisLockUtil.lock(DAYLIVELOCKNAME, DAYLIVELOCKNAME, 5 * 60 * 1000L, 3, 1L); try { if (lock) {
redis集群实现分布式锁
load2006的专栏
03-23 5473
好久没写博客了，突然想起来以前看老外博客上redis做分布式锁的想法。 实现一个DLM（distributed lock manager）主要需要考虑一下几个问题： 1. lock server本身需要是高可用的，如果是多个节点，需要保证2n+1个节点只要n+1个节点可用则服务可用 2.分布式系统里，申请lock的client可能会宕机，因此每个锁，必须有一个expire时间，系统可以回收
Redis从入门到精通(八)Redis实战(五)分布式锁误删与原子性问题、Redisson 测试项目代码
最新发布
04-06
在本篇中，我们将深入探讨Redis的分布式锁及其在实际应用中的挑战，特别是关于误删与原子性问题。Redis作为一款高性能的键值存储系统，常被用于实现分布式锁，以保证多节点间的同步和数据一致性。而Redisson是基于...
muke redis 从入门到可用 分布式实践
10-22
muke redis 从入门到可用 分布式实践
redis实现分布式锁
qq_41560011的博客
03-17 581
当前java开发最火热的开发方式应该都是使用springboot来进行开发,springboot的优点这里就不做过多叙述 这里使用springboot RedisTemplate实现分布式锁; 上代码前先说明,redis实现分布式锁，是利用redis唯一key的特性,唯一key创建时如果成功会返回1(true),已经存在无法创建会返回0(false), 另redis存在事件通知订阅功能,利用该功能可以监听key删除或过期来唤醒等待锁的线程及时竞争锁(该键空间通知功能需要在redis中开启，否则不会生效) 可
Redis实现分布式锁
SSL 的博客
01-26 947
利用Springboot中的RedisTemplate实现Redis分布式锁以及优化处理
集群环境下Redis分布式锁
且听风吟的专栏
01-16 928
另外一篇文章：https://www.jianshu.com/p/fb9993d1b27e 一、前言 　　在上一篇文章中，已经介绍了基于Redis实现分布式锁的正确姿势，但是上篇文章存在一定的缺陷——它加锁只作用在一个Redis节点上，如果通过sentinel保证高可用，如果master节点由于某些原因发生了主从切换，那么就会出现锁丢失的情况： 客户端1在Redis的master节点上拿到...
redis cluster 分布式锁_redis实现分布式锁
weixin_39851008的博客
11-20 167
什么是分布式锁分布式锁是控制不同系统访问共享资源的一种锁机制，保证共享资源的可用、准确。分布式锁需要具备什么条件1.互斥（必须）：同一时刻，分布式部署的应用中，同一个方法/资源只能被一台机器上的一个线程占用。2.锁失效保护（必须）：出现客户端断电等异常情况，锁仍然能被其他客户端获取，防止死锁。3.可重入（可选）：同一个线程在没有释放锁之前，如果想再次操作，可以直接获得锁。4.阻塞/非阻塞（可选）：...
Redis集群及分布式锁
java123456111的博客
06-22 2025
1、进入/root/myredis文件目录 2、进入redis6378.conf，并添加一下内容 3、复制配置文件 4、修改配置文件批量修改命令 5、启动上面配置的六台redis服务 6、将六个节点合成一个集群组合之前，请确保所有redis实例启动后，node-xxxx.conf文件都生成正常。 7、Redis报错：-bash redis-cli command not found sudo cp src/redis-cli /usr/local/bin/8、执行下面的命令 9、连接redis集群 10、通
基于redis分布式锁_代码实现
春风化雨
06-12 2877
1、工具类实现redis分布式锁 说明，代码可以封装在工具jar中，方便各系统引用。 import com.myfutech.common.util.constant.RedisPrefix; import lombok.extern.slf4j.Slf4j; import org.springframework.data.redis.connection.RedisStringComma...
Redis分布式锁实现方案
GaoChenXi
06-14 453
目录 分布式锁场景 Redis分布式锁的简易实现 Redis分布式锁存在的问题 Lua脚本实现分布式锁一致性 RedisConnection实现分布式锁一致性 分布式锁优化分析建议 分布式锁场景 分布式锁是什么 分布式锁是控制分布式系统或不同系统之间共同访问共享资源的一种锁实现 如果不同的系统或同一个系统的不同主机之间共享了某个资源时，往往通过互斥来防止彼此干扰。 分布锁设计目的 可以保证在分布式部署的应用集群中，同一个方法在同一操作只能被一台机器上的一个线程执行。 设计要求 这把锁要是一
【Redis】Redis实现分布式锁
Decade_Faiz的博客
01-15 955
*** 尝试获取锁* @param timeoutSec 锁持有的超时时间，过期后自动释放* @return true 代表获取锁成功；false 代表获取锁失败/*** 释放锁static {} //获取锁 @Override public boolean tryLock(long timeoutSec) {//获取线程标识 String threadId = ID_PREFIX + Thread . currentThread() . getId();
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值