springboot + redis 实现分布式锁记录

今天药忘吃喽~ 2023-05-29 03:37 9阅读 0赞

分布式锁： 一个集群中多台jvm 只有一台能够获取这个锁， 其他jvm则等待。

redis 内存数据库， 性能好。

分布式锁的实现方式有很多种，推荐使用如下两种：

1： redis 实现

2： zookeeper 实现

redis 通过  setnx + expire 命令实现分布式锁， 乐观锁方式获取。 key对应的value值为 不重复的随机数。

setnx 与 set命令的区别，  setnx 存在则返回失败，不能覆盖，  set直接覆盖。

setnx 写入一个key, key不存在则保存，返回1 成功。. key存在则不保存， 返回0失败。 key不能重复

expire  是key的存活时间。设置key的失效时间， 防止死锁。

key失效或者操作完毕删除key释放锁， 记住， 要将创建的key对应的value值返回， 在删除时判断value是否相等， value相等     才能删除

![20191103154922500.png][]

zk 通过临时节点 + 事件通知实现分布式锁。乐观锁方式获取。节点不能重复。

zk 中有 临时节点与持久节点。 实现分布式锁用的是 临时节点，

哪台jvm 能够在zk创建成功 临时节点， 则获取锁，  其他则等待。 节点的创建与删除都有事件通知。

断开会话则删除节点， 释放锁。设置 session的时间防止死锁。

性能对比：

redis 比  zk 快， 毕竟 redis是内存数据库， zk在硬盘上。

稳定性：

zk  比 redis好。 zk是事件通知，稳定性比redis好。

代码实现：

pom 引入依赖：

<dependencies>
    		<dependency>
    			<groupId>redis.clients</groupId>
    			<artifactId>jedis</artifactId>
    			<version>3.1.0</version>
    		</dependency>
    
    		<dependency>
    			<groupId>org.apache.commons</groupId>
    			<artifactId>commons-lang3</artifactId>
    			<version>3.9</version>
    		</dependency>
    	</dependencies>

代码：

/** 
     * Project Name:servive-redislock 
     * File Name:Lock.java 
     * Package Name:com.tang.service 
     * Date:2019年11月7日 下午9:21:13 
     * Copyright (c) 2019, 
     * 
     */
    package com.tang.service;
    
    import java.time.LocalDateTime;
    import java.util.UUID;
    
    import org.apache.commons.lang3.StringUtils;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    /** 
     * ClassName: Lock
     * Function: 获取redis锁与释放redis锁
     * date: 2019年11月7日 下午9:21:13
     * 
     * @author tangjiandong
     */
    public class Lock {
    	
    		//redis 线程池
    		private JedisPool jedisPool;
    		
    		//唯一key, 获取锁的条件就是看是否可以创建这个key
    		private static final String redisKey = "redis_lock";
    		
    		public Lock(JedisPool jedisPool)
    		{
    			 this.jedisPool = jedisPool;
    		}
    	  
    		/**
    		 * getRedisLock
    		 * (获取锁)
    		 * 
    		 * @param beginTime 获取锁之前的等待时间 (单位毫秒)
    		 * @param endTime  redis Key的失效时间 (单位毫秒)
    		 * @return
    		 */
    	    public String getRedisLock(Long beginTime, Long endTime)
    	    {
    	    	Jedis conn = null;
    	    	
    	    	//key对应的值， 在释放锁时判断是否是传入key的value的判断条件。
    	    	String value = UUID.randomUUID().toString();
    	    	
    	    	int expireTime = (int)(endTime / 1000); //redis时间单位为秒, 这是redis Key的失效时间
    	    	
    	    	//循环方式获取锁， 乐观锁方式， 系统时间加等待时间为获取锁的等待时间，
    	    	Long waitTimeOut = System.currentTimeMillis() + beginTime;
    	    	
    	    	try {
    	    		conn = jedisPool.getResource();
    	    		
    	    		//系统时间小于等待时间，继续循环获取锁，超时退出返回
    		    	while(System.currentTimeMillis() < waitTimeOut)
    		    	{
    		    		//setnx 方法key值唯一，成功保存返回1, 失败返回0， 成功代表key不存在进行 保存，失败代表key存在
    		    		if(1 == conn.setnx(redisKey, value))
    		    		{
    		    			//设置key的失效时间， 防止死锁.
    		    			conn.expire(redisKey, expireTime);
    		    			
    		    			//返回value, 在释放锁时进行判断，防止释放不是当前锁的错误。
    		    			return value;
    		    		}
    		    	}
    			} catch (Exception e) {
    				e.printStackTrace();
    				//异常可以自定义。
    				throw new RuntimeException("获取redis锁时异常!");
    			}finally {
    				if (null != conn)
    				{
    					conn.close();
    				}
    			}
    	    	
    	    	//获取锁超时。
    	    	return null;
    	    }
    	    
    	    
    	    /**
    	     * unRedisLock
    	     * 释放redis锁
    	     * 
    	     * @return
    	     */
    	    public void unRedisLock(String value)
    	    {
    	    	Jedis conn = null;
    	    	try {
    	    		// 1.建立redis连接
    				conn = jedisPool.getResource();
    				
    				String  str = conn.get(redisKey);
    	    		//判断是否为当前值的锁，是当前锁才能释放
    	    		if(StringUtils.isNotBlank(str) && str.equals(value))
    	    		{
    	    			//释放锁
    		    		conn.del(redisKey);
    		    		System.out.println("2：释放锁...value:" + value);
    	    		}else {
    	    			System.out.println("2：释放锁失败... key: " +redisKey+ " : value: " + value);
    	    		}
    			} catch (Exception e) {
    				e.printStackTrace();
    				//异常可以自定义。
    				throw new RuntimeException("释放redis锁时异常!");
    			}finally {
    				if (null != conn)
    				{
    					conn.close();
    				}
    			}
    	    }
    }
    
    /**
     * 
     * ClassName: LockService
     * Function: 配置连接redis线程池 
     * date: 2019年11月9日 下午4:27:20
     * 
     * @author tangjiandong
     */
    class LockService {
        //如果使用的jedispool来得到的jedis，那cloese操作不是关闭，而是归还给线程池
    	private static JedisPool jedisPool = null;
    	
    	static {
    		//redis线程池配置
    		JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
    		//最大连接数
    		jedisPoolConfig.setMaxTotal(200);
    		//最大空闲数
    		jedisPoolConfig.setMaxIdle(8);
    		//最大等待时间
    		jedisPoolConfig.setMaxWaitMillis(1000 * 100);
    		
    		//在borrow一个jedis实例时，是否提前进行alidate操作；如果为true，则得到的jedis实例均是可用的
    		//向资源池借用连接时是否做连接有效性检查(ping)，无效连接会被移除,建议false,默认值false
    		//jedisPoolConfig.setTestOnBorrow(true);
    		
    		//配置，地址， 端口， 超时时间， 客户端密码（没有密码则不填）
    		jedisPool = new JedisPool(jedisPoolConfig, "redis服务端IP", 6379, 3000, "123456");
    		
    	}
    	
    	private Lock lock = new Lock(jedisPool);
    	
    	public void test()
    	{
    		String value = lock.getRedisLock(5000L, 5000L);
    		
    		if(null == value)
    		{
    			System.out.println(Thread.currentThread().getName() + " 锁获取失败");
    			return;
    		}
    		
    		System.out.println("1：获取锁...value:" + value);
    		
    		//释放锁
    		lock.unRedisLock(value);
    	}
    }

测试：

/** 
     * Project Name:servive-redislock 
     * File Name:Tests.java 
     * Package Name:com.tang.service 
     * Date:2019年11月8日 下午10:40:36 
     * Copyright (c) 2019, 
     * 
     */
    package com.tang.service;
    
    
    /** 
     * ClassName: Tests
     * Function: TODO ADD FUNCTION. 
     * date: 2019年11月8日 下午10:40:36
     * 
     * @author tangjiandong
     */
    public class Tests {
      
    	public static void main(String[] args) {
    		LockService LockService = new LockService();
    		for (int i = 0; i < 10; i++)
    		{
    			new Thread(new Runnable()
    			{
    				@Override
    				public void run() 
    				{
    					
    					LockService.test();
    				}
    			}).start();
    		}
    		
    		
       }
    }

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhbmdfamlhbl9kb25n_size_16_color_FFFFFF_t_70][]

[20191103154922500.png]: https://img-blog.csdnimg.cn/20191103154922500.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhbmdfamlhbl9kb25n_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191109163845494.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhbmdfamlhbl9kb25n,size_16,color_FFFFFF,t_70