基于Redis实现的分布式锁

最新推荐文章于 2024-10-10 14:01:06 发布
最新推荐文章于 2024-10-10 14:01:06 发布
阅读量2.2k 收藏 5
点赞数 1
分类专栏： Java redis 文章标签： redis 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljinshuan/article/details/72025282
版权

基于Redis的分布式锁实现

背景

  • 根据redis的setnx命令实现只有一个客户端可以拿到锁；
  • RedissonLock的分布式锁实现使用了lua脚本，这里提供一种不适用脚本实现的方法；

基本实现

  • 使用redis的setnx命令，再加上一个过期时间防止死锁
  • 缺点：不支持重入，不支持wait，如果调用unlock的时间>leaseTime，则会删除之后获得的锁；
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.util.concurrent.TimeUnit;

/**
 * Created by jinshuan.li on 2016/12/1.
 */
public class DefaultDistrLock implements DistrLock {

    private static JedisPool jedisPool = null;
    private static Long DEFAULT_LEASE_TIME = 30000L;
    private String lockKey;

    public DefaultDistrLock(String lockKey) {
        this.lockKey = lockKey;
    }

    /**
     * 初始化
     *
     * @param jedisPool
     */
    public static void init(JedisPool jedisPool) {
        DefaultDistrLock.jedisPool = jedisPool;
    }

    @Override
    public boolean tryLock() {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            Long setnx = jedis.setnx(lockKey, String.valueOf(Thread.currentThread().getId()));
            if (setnx.equals(1L)) {
                jedis.pexpire(lockKey, DEFAULT_LEASE_TIME);
                return true;
            }
        } finally {
            closeJedis(jedis);
        }
        return false;
    }

    @Override
    public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            Long setnx = jedis.setnx(lockKey, String.valueOf(Thread.currentThread().getId()));
            if (setnx.equals(1L)) {
                long toMillis = unit.toMillis(leaseTime);
                jedis.pexpire(lockKey, toMillis);
                return true;
            }
        } finally {
            closeJedis(jedis);
        }
        return false;
    }

    @Override
    public void unlock() {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.del(lockKey);
        } finally {
            closeJedis(jedis);
        }
    }

    private void closeJedis(Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }
}

可重入的分布式锁实现

  • 思路：在setnx失败之后，查看其value是否为特定值，如果是，则可以继续获取锁。同时加入holdCount记录锁的层数，unlock时也要进行相应处理
  • 缺点：不可等待，每次竞争锁都需要访问redis
/**
 * Created by jinshuan.li on 2016/12/1.
 */
public class DefaultDistrLock implements DistrLock {

    private static JedisPool jedisPool = null;
    private static Long DEFAULT_LEASE_TIME = 30000L;
    private String lockKey;
    private String uuid = UUID.randomUUID().toString();

    private AtomicInteger holdCount = new AtomicInteger(0);

    public DefaultDistrLock(String lockKey) {
        this.lockKey = lockKey;
    }

    /**
     * 初始化
     *
     * @param jedisPool
     */
    public static void init(JedisPool jedisPool) {
        DefaultDistrLock.jedisPool = jedisPool;
    }

    @Override
    public boolean tryLock() {

        Jedis jedis = null;
        try {
            String setValue=uuid + Thread.currentThread().getId();
            jedis = jedisPool.getResource();
            Long setnx = jedis.setnx(lockKey, setValue);
            if (setnx.equals(1L)) {
                jedis.pexpire(lockKey, DEFAULT_LEASE_TIME);
                holdCount.incrementAndGet();
                return true;
            }
            String value = jedis.get(lockKey);
            if (StringUtils.equals(uuid + Thread.currentThread().getId(), value)) {
                // 可重入
                holdCount.incrementAndGet();
                return true;
            }
        } finally {
            closeJedis(jedis);
        }
        //没有获得锁 设置为0
        holdCount = new AtomicInteger(0);
        return false;
    }

    @Override
    public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) {
        Jedis jedis = null;
        try {
            String setValue=uuid + Thread.currentThread().getId();
            jedis = jedisPool.getResource();
            Long setnx = jedis.setnx(lockKey, setValue);
            if (setnx.equals(1L)) {
                long toMillis = unit.toMillis(leaseTime);
                jedis.pexpire(lockKey, toMillis);
                holdCount.incrementAndGet();
                return true;
            }
            String value = jedis.get(lockKey);
            if (StringUtils.equals(uuid + Thread.currentThread().getId(), value)) {
                // 可重入
                holdCount.incrementAndGet();
                return true;
            }
        } finally {
            closeJedis(jedis);
        }
        holdCount = new AtomicInteger(0);
        return false;
    }

    @Override
    public void unlock() {
        final int countValue = holdCount.decrementAndGet();
        if (countValue < 0) {
            throw new IllegalStateException("this thread does not get lock");
        }
        if (countValue == 0) {
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                jedis.del(lockKey);
            } finally {
                closeJedis(jedis);
            }
        }
    }

    private void closeJedis(Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }
}

支持重入，等待的分布式锁

  • 思路：在访问redis之前，先用一个innerLock拿到本地jvm的锁，原因是：如果在本地线程中都竞争不过，在分布式环境下则更竞争不过其他线程；
  • 因此同时访问redis的并发只跟机器数目有关；
  • 等待的实现，通过redis的pub、sub实现，同时使用countDownLatch来等待；在sub的通知中countDown以激活等待线程；
  • 最终不断重试来获取锁；
import org.apache.commons.lang.StringUtils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPubSub;

import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by jinshuan.li on 2016/12/1.
 */
public class DefaultDistrLock implements DistrLock {

    private static JedisPool jedisPool = null;
    private static Long DEFAULT_LEASE_TIME = 30000L; // 默认租约时间
    private static ExecutorService executorService = Executors.newFixedThreadPool(5);
    private String lockKey;
    private String uuid = UUID.randomUUID().toString();
    private Lock innerLock = new ReentrantLock();
    private CountDownLatch countDownLatch = new CountDownLatch(1);
    JedisPubSub pubSub = new JedisPubSub() {
        @Override
        public void onMessage(String channel, String message) {
            if (StringUtils.equals("DELETE", message)) {
                //有key过期了
                this.unsubscribe();
            }
        }

        @Override
        public void onUnsubscribe(String channel, int subscribedChannels) {
            //countDown以使等待线程里面结束
            countDownLatch.countDown();
        }
    };
    private AtomicInteger holdCount = new AtomicInteger(0);
    private long firstAccireTime = 0;
    private long leaseTime = DEFAULT_LEASE_TIME;

    public DefaultDistrLock(String lockKey) {
        this.lockKey = lockKey;
    }


    /**
     * 初始化
     *
     * @param jedisPool
     */
    public static void init(JedisPool jedisPool) {
        DefaultDistrLock.jedisPool = jedisPool;
    }

    @Override
    public boolean tryLock() {

        boolean getLocalLock = false;
        Jedis jedis = null;
        try {
            // 首先要赢得内部竞争
            getLocalLock = innerLock.tryLock();
            if (!getLocalLock) {
                return false;
            }
            jedis = jedisPool.getResource();
            boolean remoteLock = getRemoteLock(jedis, DEFAULT_LEASE_TIME, TimeUnit.MILLISECONDS);
            if (remoteLock) {
                return true;
            }
        } finally {
            closeJedis(jedis);
        }
        // 没有获得锁 设置为0
        holdCount = new AtomicInteger(0);
        return false;
    }

    @Override
    public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) {
        Jedis jedis = null;
        boolean getLocalLock = false;
        long waitTimeMillis = unit.toMillis(waitTime);
        try {
            // 首先要赢得内部竞争
            long startTime = System.currentTimeMillis();
            getLocalLock = innerLock.tryLock(waitTime, TimeUnit.MILLISECONDS);
            if (!getLocalLock) {
                return false;
            }
            jedis = jedisPool.getResource();
            // 尝试获取锁
            boolean remoteLock = getRemoteLock(jedis, leaseTime, unit);
            if (remoteLock) {
                return true;
            }
            // 根据等待时间不断尝试
            while (true) {
                long lastWaitTime = waitTimeMillis - (System.currentTimeMillis() - startTime); // 还可以等待的时间
                if (lastWaitTime <= 0) {
                    break;
                }
                Long pttl = jedis.pttl(lockKey);
                if (null == pttl) {
                    break;
                }
                long shouldWaitTime = pttl < lastWaitTime ? pttl : lastWaitTime;
                if (shouldWaitTime != 0) {
                    if (countDownLatch.getCount() != 1) {
                        countDownLatch = new CountDownLatch(1);//重新赋值
                    }
                    subscribeDelete(); //订阅
                    countDownLatch.await(shouldWaitTime, TimeUnit.MILLISECONDS); // 等这么久
                }
                lastWaitTime = waitTimeMillis - (System.currentTimeMillis() - startTime); // 再次计算时间
                if (lastWaitTime > 0) {
                    // 还有时间 尝试获取锁
                    remoteLock = getRemoteLock(jedis, leaseTime, unit);
                    if (remoteLock) {
                        return true;
                    }
                } else {
                    break;
                }
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            closeJedis(jedis);
        }
        holdCount = new AtomicInteger(0);
        return false;
    }

    private JedisPubSub subscribeDelete() {
        if (pubSub.isSubscribed()) {
            return pubSub;
        }
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                Jedis jedis1 = null;
                try {
                    jedis1 = jedisPool.getResource();
                    jedis1.subscribe(pubSub, lockKey + "-channel");
                } finally {
                    closeJedis(jedis1);
                }
            }
        });

        return pubSub;
    }

    @Override
    public void unlock() {
        innerLock.unlock();
        if (holdCount.get() > 0) {
            // 此时才删除
            final int countValue = holdCount.decrementAndGet();
            if (countValue != 0) {
                return;
            }
            // 此处直接删除会有问题 考虑一种情况： unlock的时间已经过了leaseTime,key因为超时过期，key被其他线程获取 直接删除会把不属于该对象的key删除
            if (System.currentTimeMillis() - firstAccireTime >= leaseTime) {
                //如果当前时间大于租约时间 不处理
                return;
            }
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                jedis.del(lockKey);
                jedis.publish(lockKey + "-channel", "DELETE"); //发消息
            } finally {
                closeJedis(jedis);
            }

        }
    }

    private void closeJedis(Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }

    /**
     * 获取远程锁
     *
     * @param jedis
     * @param leaseTime
     * @param unit
     * @return
     */
    private boolean getRemoteLock(Jedis jedis, long leaseTime, TimeUnit unit) {
        String setValue = uuid + Thread.currentThread().getId();
        Long setnx = jedis.setnx(lockKey, setValue);
        if (setnx.equals(1L)) {
            long toMillis = unit.toMillis(leaseTime);
            jedis.pexpire(lockKey, toMillis);
            firstAccireTime = System.currentTimeMillis();
            this.leaseTime = leaseTime;
            holdCount.incrementAndGet();
            return true;
        }
        String value = jedis.get(lockKey);
        if (StringUtils.equals(setValue, value)) {
            // 可重入
            holdCount.incrementAndGet();
            return true;
        }
        return false;
    }
}
ljinshuan
关注
专栏目录
基于Redis实现分布式锁
daiyudong2020的博客
06-26 7299
分布式锁的基本功能： 1.同一时刻只能存在一个锁 2.需要解决意外死锁问题，也就是锁能超时自动释放 3.支持主动释放锁 分布式锁解决什么问题： 多进程并发执行任务时，需要保证任务的有序性或者唯一性 准备： redis版本>=2.6 redis是主从+sentinel模式 原理： redis2.6之后，SET命令支持超时和key存在检查，这是一个原子操作 获取锁
Java基于redis实现分布式锁代码实例
08-19
Java基于Redis实现分布式锁代码实例 分布式锁的必要性 在多线程环境中，资源竞争是一个常见的问题。例如，在一个简单的用户操作中，一个线程修改用户状态，首先在内存中读取用户状态，然后在内存中进行修改，然后...
20-Redis 怎样实现的分布式锁？
cenghaihengliu的博客
06-22 158
“锁”是我们实际工作和面试中无法避开的话题之一，正确使用锁可以保证高并发环境下程序的正确执行，也就是说只有使用锁才能保证多人同时访问时程序不会出现问题。 我们本课时的面试题是，什么是分布式锁？如何实现分布式锁？ 典型回答 第 06 课时讲了单机锁的一些知识，包括悲观锁、乐观锁、可重入锁、共享锁和独占锁等内容，但它们都属于单机锁也就是程序级别的锁，如果在分布式环境下使用就会出现锁不生效的问题，因此我们需要使用分布式锁来解决这个问题。 分布式锁是控制分布式系统之间同步访问共享资源的一种方式。是为了解决分布式系统
使用 Redis 实现分布式锁：原理、实现与优化
最新发布
欢迎来到【技术拾光者】，在这里，我们专注分享编程教程、技术趋势、实战案例和优质资源。不定期举办技术问答、专家访谈和职业指导。加入我们，共同探索技术世界，提升技能，拓展职业道路！
10-10 1726
在分布式系统中，分布式锁是确保多个进程或线程在同一时间内对共享资源进行互斥访问的关键机制。本文详细介绍了如何使用 Redis 实现分布式锁，包括基本原理、实现方法、示例代码以及优化建议。通过 Redis 的 SETNX 命令和 Lua 脚本，可以实现高效且可靠的分布式锁。同时，本文还探讨了 Redlock 算法的应用，以提高分布式锁的可靠性和容错性。
Redis分布式锁的正确实现方式
OceanSky的专栏
03-19 2112
1.前言 分布式锁一般有三种实现方式： 数据库乐观锁 基于Redis的分布式锁 基于Zookeeper的分布式锁 本文介绍的是基于Redis的分布式锁； 2.可靠性 首先，为了确保分布式锁可用，需要锁至少满足以下四个条件： 互斥性，在任意时刻，只有一个客户端能持有锁。 不会发生死锁，即使有一个客户端在持有锁的期间崩溃而没有主动释放锁，也能保证后续其它客户端能加锁。 具有容错性。只要大部分Re...
怎样实现redis分布式锁
leo3070的博客
05-04 1600
如果在一个分布式系统中，我们从数据库中读取一个数据，然后修改保存，这种情况很容易遇到并发问题。因为读取和更新保存不是一个原子操作，在并发时就会导致数据的不正确。这种场景其实并不少见，比如电商秒杀活动，库存数量的更新就会遇到。如果是单机应用，直接使用本地锁就可以避免。如果是分布式应用，本地锁派不上用场，这时就需要引入分布式锁来解决。 由此可见分布式锁的目的其实很简单，就是为了保证多台服务器在执行某一段代码时保证只有一台服务器执行。 为了保证分布式锁的可用性，至少要确保锁的实现要同时满足以下几点： 互斥性
Redis 分布式锁详解（七种实现方式）
new_baibai的博客
05-19 1万+
Redis 分布式锁七种实现方式
基于redis实现分布式锁的原理与方法
12-14
redis实现分布式锁 数据库实现分布式锁 zk实现分布式锁 今天我们介绍通过redis实现分布式锁。实际上这三种和java对比看属于一类。都是属于程序外部锁。 原理剖析 上述三种分布式锁都是通过各自为依据对各个请求...
redis实现分布式锁,自旋式加锁,lua原子性解锁
07-16
本文将深入探讨如何使用Redis实现分布式锁，以及如何利用自旋式加锁和Lua脚本实现原子性解锁。 首先，我们来理解分布式锁的基本概念。分布式锁是在多节点之间共享资源时，用于协调各个节点的访问控制机制。在分布式...
基于Redis的分布式锁的实现方案.pdf
08-09
本文讨论了分布式锁的实现方案，主要基于Redis实现分布式锁，以解决分布式系统中资源访问的同步问题。在分布式系统中，需要协调各个系统或主机之间的资源访问，以避免彼此干扰和保证一致性。分布式锁是控制分布式...
基于Redis实现分布式锁以及任务队列
12-16
一、前言 　双十一刚过不久，大家都知道在天猫、京东、苏宁等等电商网站上有很多秒杀活动，例如在某一个时刻抢购一个原价1999现在秒杀价只要999的手机时，会迎来一个用户请求的高峰期，可能会有几十万几百万的并发量...
Redis分布式锁的实现方式(redis面试题)
12-15
什么是分布式锁？ 要介绍分布式锁，首先要提到与分布式锁相对应的是线程锁、进程锁。 线程锁：主要用来给方法、代码块加锁。当某个方法或代码使用锁，在同一时刻仅有一个线程执行该方法或该代码段。线程锁只在同一JVM中有效果，因为线程锁的实现在根本上是依靠线程之间共享内存实现的，比如synchronized是共享对象头，显示锁Lock是共享某个变量（state）。 进程锁：为了控制同一操作系统中多个进程访问某个共享资源，因为进程具有独立性，各个进程无法访问其他进程的资源，因此无法通过synchronized等线程锁实现进程锁。 分布式锁：当多个进程不在同一个系统中，用分布式锁控制多个进程对资源的访问。
基于Redis方式实现分布式锁
09-24
基于Redis方式实现分布式锁
redis如何实现分布式锁
随我的博客
06-13 2万+
1.分布式锁需要解决的问题 互斥性：任意时刻只能有一个客户端拥有锁，不能同时多个客户端获取 安全性：锁只能被持有该锁的用户删除，而不能被其他用户删除 死锁：获取锁的客户端因为某些原因而宕机，而未能释放锁，其他客户端无法获取此锁，需要有机制来避免该类问题的发生 容错：当部分节点宕机，客户端仍能获取锁或者释放锁 2.如何通过Redis实现分布式锁:(非完善方法) SETNX key value ...
Redis如何实现分布式锁？
m0_50180963的博客
02-22 545
前言 如果在一个分布式系统中，我们从数据库中读取一个数据，然后修改保存，这种情况很容易遇到并发问题。因为读取和更新保存不是一个原子操作，在并发时就会导致数据的不正确。这种场景其实并不少见，比如电商秒杀活动，库存数量的更新就会遇到。如果是单机应用，直接使用本地锁就可以避免。如果是分布式应用，本地锁派不上用场，这时就需要引入分布式锁来解决。 由此可见分布式锁的目的其实很简单，就是为了保证多台服务器在执行某一段代码时保证只有一台服务器执行。 为了保证分布式锁的可用性，至少要确保锁的实现要同时满足以下几点：
【Redis】Redis 如何实现分布式锁
迪曼奥特迦-博客
03-04 2008
分布式锁其实就是，控制分布式系统不同进程共同访问共享资源的一种锁的实现。如果不同的系统或同一个系统的不同主机之间共享了某个临界资源，往往需要互斥来防止彼此干扰，以保证一致性。
如何用Redis实现分布式锁？
热门推荐
小夏陌的博客
05-01 4万+
分布锁很重要，经常作为面试考题，接下来就让我们一起来了解下分布式锁
（七）Redis分布式锁的实现
roothahh的博客
05-02 865
（一）分布式锁概念： 在Java中synchronized关键字和ReentrantLock可重入锁在我们的代码中是经常见的，一般我们用其在多线程环境中控制对资源的并发访问，但是随着分布式的快速发展，本地的加锁往往不能满足我们的需要，需要做集群，一个应用需要部署到几台机器上然后做负载均衡 分布式锁其实就是，控制分布式系统不同进程共同访问共享资源的一种锁的实现。如果不同的系统或同一个系统的不同主机之间共享了某个临界资源，往往需要互斥来防止彼此干扰，以保证一致性 分布式锁的特征: 互斥性：互斥是所得基
基于redis实现分布式锁
07-29
基于 Redis 实现分布式锁可以利用 Redis 的原子性操作和超时特性来实现。下面是一个基本的实现思路： 1. 获取锁：使用 Redis 的 SETNX 命令，如果指定的锁 key 不存在，则设置该 key 的值为当前时间戳加上锁的超时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值