Redis分布式锁实现

最新推荐文章于 2021-07-06 17:56:46 发布
最新推荐文章于 2021-07-06 17:56:46 发布
阅读量136 收藏
点赞数
分类专栏： redis 文章标签： Redis Jedis Redisson Redis集群 分布式锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011976388/article/details/83791933
版权

一，Jedis分布式锁实现——单点

    1，Jar包引入

<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>2.9.0</version>
    </dependency>

    2，单例模式实现Jedis获取

/**
 * Redis单点构建初始化
 * @return Jedis客户端
 */
public static Jedis createJedisSingle() {
	if (null == jedisPool) {
		synchronized (JedisConnectionUtils.class) {
			if (null == jedisPool) {
				JedisPoolConfig config = new JedisPoolConfig();
				config.setMaxTotal(10);
				jedisPool = new JedisPool(config, "192.168.91.129", 6379);
			}
		}
	}
	return jedisPool.getResource();
}

    3，锁获取和释放实现

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

import java.util.UUID;

/**
 * 基于Redis单点服务进行分布式锁处理
 * 应用Jedis客户端的watch命令保证原子性
 * @author pj_zhang
 * @create 2018-11-05 21:42
 **/
public class DistributedSingleLockUtils {

    /**
     * 获取锁
     * @param lockName 锁名称
     * @param lockTime 锁过期时间
     * @param outLockTime 获取锁时间
     * @return
     */
    public static String getLock(String lockName, Long lockTime, Long outLockTime) {
        // 获取唯一锁标识
        String lockIdentify = UUID.randomUUID().toString();
        // 拼接锁KEY
        String lockKey = "lock:" + lockName;
        // 获取锁超时时间, 秒数
        Integer lockTimeSecond = Integer.valueOf(String.valueOf(lockTime / 1000));
        Jedis jedis = null;
        try {
            // 获取jedisCluster
            jedis = JedisConnectionUtils.createJedisSingle();
            // 根据加锁时间, 进行加锁
            Long endTime = System.currentTimeMillis() + outLockTime;
            while (System.currentTimeMillis() < endTime) {
                // 设置值成功, 定时时间跑完后, 会自动删除该KEY
                // setnx 不存在返回1, 存在则返回0
                if (jedis.setnx(lockKey, lockIdentify) == 1) {
                    // 设置定时时间
                    jedis.expire(lockKey, lockTimeSecond);
                    // 获取锁成功, 返回锁标识
                    return lockIdentify;
                }
                // 获取锁未成功, 线程沉睡后继续获取
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            jedis.close();
        }
        return null;
    }

    /**
     * 释放锁
     * @param lockName 锁名称
     * @param lockIdentify 锁唯一标识
     * @return
     */
    public static boolean releaseLock(String lockName, String lockIdentify) {
        String lockKey = "lock:" + lockName;
        Jedis jedis = null;
        boolean isRelease =false;
        try {
            jedis = JedisConnectionUtils.createJedisSingle();
            while (true) {
                // 使用watch命令, 保证原子性
                jedis.watch(lockName);
                if (null != lockIdentify && lockIdentify.equals(jedis.get(lockKey))) {
                    Transaction transaction = jedis.multi();
                    transaction.del(lockName);
                    if (transaction.exec().isEmpty()) {
                        continue;
                    }
                    isRelease = true;
                }
                jedis.unwatch();
                break;
            }
        } finally {
            jedis.close();
        }
        return isRelease;
    }

}

    4，多线程测试

public static void testJedisSingle() {
	for (int i = 0; i < 10; i++) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					String identify = DistributedSingleLockUtils.getLock("zpj", 2000L, 2000L);
					if (null != identify) {
						System.out.println(Thread.currentThread().getName() + "获取锁成功 : " + identify);
					} else {
						continue;
					}
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					boolean result = DistributedSingleLockUtils.releaseLock("zpj", identify);
					if (result) {
						System.out.println(Thread.currentThread().getName() + "释放锁成功 : " + identify);
						break;
					}
				}
			}
		}, "Thread_" + i).start();
	}
}

二，Jedis分布式锁实现——集群

    1，单例获取实现JedisCluster获取

/**
 * redis集群构建初始化
 * @return JedisCluster客户端
 */
public static JedisCluster createJedisCluster() {
	if (null == jedisPool) {
		synchronized (JedisConnectionUtils.class) {
			if (null == jedisPool) {
				JedisPoolConfig config = new JedisPoolConfig();
				config.setMaxTotal(10);
				Set<HostAndPort> lstHostAndPort = new HashSet<>(10);
				lstHostAndPort.add(new HostAndPort("192.168.91.128", 6379));
				lstHostAndPort.add(new HostAndPort("192.168.91.128", 6380));
				lstHostAndPort.add(new HostAndPort("192.168.91.129", 6379));
				lstHostAndPort.add(new HostAndPort("192.168.91.129", 6380));
				lstHostAndPort.add(new HostAndPort("192.168.91.130", 6379));
				lstHostAndPort.add(new HostAndPort("192.168.91.130", 6380));
				jedisCluster = new JedisCluster(lstHostAndPort, config);
			}
		}
	}
	return jedisCluster;
}

    2，锁获取和释放实现（锁获取和单点基本一致，释放锁时候原子性保证不一致，JedisCluster不支持watch命令）

import redis.clients.jedis.JedisCluster;

import java.io.IOException;
import java.util.UUID;

/**
 * 基于Redis集群进行分布式锁处理
 * 应用LUA脚本保证原子性
 **/
public class DistributedClusterLockUtils {

    /**
     * 获取锁
     * @param lockName 锁名称
     * @param lockTime 锁过期时间
     * @param outLockTime 获取锁时间
     * @return
     */
    public static String getLock(String lockName, Long lockTime, Long outLockTime) {
        // 获取唯一锁标识
        String lockIdentify = UUID.randomUUID().toString();
        // 拼接锁KEY
        String lockKey = "lock:" + lockName;
        // 获取锁超时时间, 秒数
        Integer lockTimeSecond = Integer.valueOf(String.valueOf(lockTime / 1000));
        JedisCluster jedisCluster = null;
        try {
            // 获取jedisCluster
            jedisCluster = JedisConnectionUtils.createJedisCluster();
            // 根据加锁时间, 进行加锁
            Long endTime = System.currentTimeMillis() + outLockTime;
            while (System.currentTimeMillis() < endTime) {
                // 设置值成功, 定时时间跑完后, 会自动删除该KEY
                // setnx 不存在返回1, 存在返回0
                if (jedisCluster.setnx(lockKey, lockIdentify) == 1) {
                    // 设置定时时间
                    jedisCluster.expire(lockKey, lockTimeSecond);
                    // 获取锁成功, 返回锁标识
                    return lockIdentify;
                }
                // 获取锁未成功, 线程沉睡后继续获取
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                jedisCluster.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 释放锁
     * @param lockName 锁名称
     * @param lockIdentify 锁唯一标识
     * @return
     */
    public static boolean releaseLock(String lockName, String lockIdentify) {
        String lockKey = "lock:" + lockName;
        JedisCluster jedisCluster = null;
        boolean isRelease =false;
        try {
            while (true) {
                // 获取连接
                jedisCluster = JedisConnectionUtils.createJedisCluster();
                // 集群状态下, 使用LUA脚本保证原子性
                String luaScript = " if redis.call('get', KEYS[1]) == ARGV[1] " +
                        " then return redis.call('del', KEYS[1]) " +
                        " else return 0 end ";
                long eval = (long) jedisCluster.eval(luaScript, 1, lockKey, lockIdentify);
                if (0L < eval) {
                    isRelease = true;
                    break;
                }
                continue;
            }
        } finally {
            try {
                jedisCluster.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return isRelease;
    }

}

    3，多线程测试

三，Redisson分布式锁实现

    1，Jar包引入

<!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
    <dependency>
      <groupId>org.redisson</groupId>
      <artifactId>redisson</artifactId>
      <version>3.8.2</version>
    </dependency>

    2，多线程测试（已经进行完整的获取锁和释放锁封装）

         * 单点和集群模式只在获取Redisson客户端时存在不同

package com.gupao.redis.lock.jedis;

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

import java.util.concurrent.TimeUnit;

/**
 * 基于Redisson客户端实现分布式锁
 **/
public class DistributedRedissonLockUtils {

    public static void main(String[] args) {
        Config config = new Config();
        // 集群模式
        config.useClusterServers().addNodeAddress("redis://192.168.91.128:6379",
                "redis://192.168.91.128:6380",
                "redis://192.168.91.129:6379",
                "redis://192.168.91.129:6380",
                "redis://192.168.91.130:6379",
                "redis://192.168.91.130:6380");
        // 单点模式
        // config.useSingleServer().setAddress("redis://192.168.91.130:6379");
        final RedissonClient redissonClient = Redisson.create(config);
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        while (true) {
                            RLock rLock = redissonClient.getLock("myTest");
                            boolean lockResult = rLock.tryLock(20l, TimeUnit.SECONDS);
                            if (lockResult) {
                                System.out.println(Thread.currentThread().getName() + "获得锁成功");
                                Thread.sleep(100);
                                rLock.unlock();
                                System.out.println(Thread.currentThread().getName() + "释放锁成功");
                                break;
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "Thread_" + i).start();
        }
    }

}

四，布隆过滤器（基于google.guava）

    1，Jar包引入

<!-- guava提供的布隆过滤器 -->
    <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>27.0-jre</version>
    </dependency>
  </dependencies>

    2，功能实现

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import redis.clients.jedis.*;

import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class BloomFilterTest {

    public static void main(String[] args) {
        BloomFilter bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.forName("UTF-8")), 10000000, 0.00001);
        bloomFilter.put("test");
        System.out.println(bloomFilter.mightContain("test"));
    }

}

 

传说中的靖哥哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot 集成redis集群配置JedisCluster，并用redis实现分布式锁
fajing_feiyue的博客
09-28 4676
一、redis在工作是一个常见的工具，这里对redis和springboot形成集群做一个简单示例。 （1）引入对应redis集群所需要maven文件 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifac...
redis 加锁新方法 - jedisCluster.set(key,value,"NX","EX",expireSeconds);
热门推荐
wangpeng322的博客
07-27 3万+
参考：https://blog.csdn.net/Dennis_ukagaka/article/details/78072274   incr、incrBy、setnx的加锁方式都是有缺陷的，现在使用set方法加锁： jedisCluster.set(key, value, "NX", "EX", expireSeconds);  // SET IF NOT EXIST，而且还是原子的 操...
基于jedis.setnx(key, value)实现分布式锁
C18298182575的博客
12-31 4657
在单实例的环境中，java中实现锁的方式一般采用ReentrantLock类或者synchronized关键字来实现； 而在分布式环境中，就必须考虑同步访问可能引发的一些问题了，如定时任务。 而redis的一个特性就能很好的满足分布式锁要求：单实例执行； 实现方式可以基于数据库，zookeeper 等达到控制的目的，单这里就不做讨论了。 既然redis能够实现，那么我们来看一下是什么原因：...
四、Redis分布式锁
L_D_Y_K的博客
01-07 775
四、Redis分布式锁 Java中的锁我们通常以synchronized 、Lock来使用它，但是只能保证在同一个JVM进程内中执行。如果在分布式集群环境下呢？分布式锁的实现有很多，比如基于数据库乐观锁、Redis、zookeeper、memcached、系统文件等。 1、命令行加锁：SET lock_key random_value NX PX 5000 执行成功，则证明客户端获取到了锁。 random_value：是客户端生成的唯一的字符串。 NX：...
redis实现分布锁
wliang578的博客
07-06 312
目录 前言 实现 注意 加解锁 jedis集群，哨兵模式在spring的配置 前言 参考：https://redis.io/commands/set 针对实现分布式锁，redis为方便用户实现，出现了set key value EX NX的系统命令进行实现。 注意：由于SET命令选项可以替换SETNX、SETEX、PSETEX、GETSET，因此在未来的 Redis 版本中，这些命令可能会被弃用并最终被删除。 所以以后可能SETNX这样的命令估计不存在了。 NX-- 仅在不存在..
Redis分布式锁实现方式及超时问题解决
08-19
Redis分布式锁实现方式及超时问题解决 本文主要介绍了Redis分布式锁实现方式及超时问题解决，通过详细的示例代码和实现原理，帮助读者理解分布式锁的应用场景和实现方式，并解决分布式锁常见的问题。 一、分布式锁...
Redis分布式锁实现Redisson 15问.doc
07-09
Redis分布式锁实现Redisson 15问 Redis分布式锁是指在分布式系统中，多个服务实例之间对同一个资源加锁的机制，以保证数据的一致性和安全性。Redisson是一个基于Redis的分布式锁实现，它提供了一个高效、可靠的加锁...
单机redis分布式锁实现原理解析
08-19
单机Redis分布式锁实现原理解析 单机Redis分布式锁是指在单机环境下使用Redis实现分布式锁的机制。分布式锁是指在分布式系统中，多个节点之间需要互斥访问共享资源时使用的锁机制。单机Redis分布式锁的实现原理是...
基于redis分布式锁实现秒杀功能
01-19
最近在项目中遇到了类似“秒杀”的业务场景，在本篇博客中，我将用一个非常简单的demo，阐述实现所谓“秒杀”的基本思路。 业务场景 所谓秒杀，从业务角度看，是短时间内多个用户“争抢”资源，这里的资源在大部分...
Java Redis分布式锁的正确实现方式详解
08-25
Java Redis分布式锁的正确实现方式详解 Java Redis分布式锁是指使用Redis实现的分布式锁机制，旨在解决分布式系统中的并发问题。分布式锁有三种实现方式：数据库乐观锁、基于Redis的分布式锁和基于ZooKeeper的...
Redis分布式锁的实现方式(redis面试题)
09-08
以下是一个基于Redis的正确分布式锁实现示例： ```java public class CorrectRedisDistributedLock { private Jedis jedis; private String lockKey; private String clientId; public ...
redis分布式锁实现
04-13
文件"DistributedLockByRedis"可能包含了具体的Redis分布式锁实现代码，包括客户端的API设计、lua脚本、续租逻辑以及容错策略等，对于理解和实现分布式锁是一个宝贵的参考资料。通过深入研究这些内容，开发者可以更...
C#实操控制并发之Lock和Redis分布式锁
最新发布
01-21
以下是一个简单的C# Redis分布式锁实现： ```csharp public bool TryAcquireLock(string lockKey, int lockTimeout) { var redis = ConnectionMultiplexer.Connect("localhost:6379"); var db = redis.Get...
基于zookeeper实现分布式锁的底层原理
R_P_J的博客
10-31 770
注：关于什么是分布式锁及其应用场景这里不赘述，需要了解请自行百度！ 一 zookeeper分布式锁原理： 原理图基于curator(zookeeper客户端框架)，具体代码实现看下官网API(很简单)，此图解释了以下问题： 多线程间如何获取锁资源？ 一个线程内重复加锁如何处理？ 争抢锁资源时如何保证性能？ 节点挂机是否会造成死锁？ 如何解决高可用？ 二 redis分布式锁RedLock算法简...
Redis实现分布式锁
weixin_34364071的博客
03-16 82
2019独角兽企业重金招聘Python工程师标准>>> ...
实战 -- Zookeeper实现分布式锁
赵庆春
08-31 3870
场景分析 比如购买商品的操作，首先获取商品的库存，判断库存是否充足，充足的话创建订单减库存，不充足的话不允许创建订单。 有一款新型笔记本电脑，库存只剩下1件的时候，有客户A、B从不同的客户端（比如网站和APP）上看中了这款电脑，两人同时进行下单操作。 A和B同时获取库存，A购买1件，库存为1，判断充足，创建订单，库存减1，B购买1件，库存为1，判断充足，创建订单，库存减1。 结果是仅剩1件...
Zookeeper节点锁实现
zp_zhang的博客
08-16 1383
Zookeeper节点锁实现理论分析     1，该功能基于zookeeper有序节点的小DEMO实现     2，新增节点后尝试对该节点加锁     3，加锁失败后，进入线程等待， 并对上一节点进行监听     4，上一节点状态变更后唤醒线程获取锁执行任务     5，执行完成后，释放锁 Zookeeper节点锁编码变现     1，jar包引入 &lt;dependency&...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值