基于Redis手工实现分布式锁

1.分布式锁概述

1.1什么是分布式锁

        随着互联网技术的不断发展，数据量的不断增加，业务逻辑日趋复杂，在这种背景下，传统的集中式系统已经无法满足我们的业务需求，分布式系统被应用在更多的场景，与单体应用不同的是，分布式系统中竞争共享资源的最小粒度从线程升级成了进程。而在分布式系统中访问共享资源就需要一种互斥机制，来解决分布式系统中控制共享资源访问的问题，以保证数据一致性，在这种情况下，我们就需要用到分布式锁。

总结：

        1）应用场景：分布式系统。

        2）作用：提供一种共享资源访问的互斥机制，保证数据一致性。

1.2分布式锁的特性

• 互斥“”在分布式系统环境下，一个方法在同一时间只能被一个线程执行（即获取锁）
• 高可用：高可用的获取锁与释放锁
• 高性能：高性能的获取锁与释放锁
• 可重入：具备可重入特性（可理解为重新进入，由多于一个任务并发使用，而不必担心数据错误）
• 防止死锁：具备锁失效机制，超时即自动解锁，
• 非阻塞：即如果线程没有获取到锁将，直接返回获取锁失败，而不会一直阻塞

2.分布式锁的实现

        目前分布式锁常见的三种实现方式：

        1、基于数据库实现分布式锁；

        2、基于缓存（Redis等）实现分布式锁；

        3、基于Zookeeper实现分布式锁。

        本文就基于Redis手工实现分布式锁，当前现在主流的是基于Redisson工具包实现（不在本文范围内），但手工实现原理基本一致。

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还实现了可重入锁（Reentrant Lock）、公平锁（Fair Lock、联锁（MultiLock）、 红锁（RedLock）、 读写锁（ReadWriteLock）等，还提供了许多分布式服务。

2.1 锁接口定义

        接口比较简单，主要定义了加锁和释放锁两个方法

package com.example.demo.redis.lock;
 
import java.util.concurrent.TimeUnit;
 
/**
 * 
* @ClassName: RedisDistributeLock
* @Description: Redis分布式锁
* @Author: liulianglin
* @DateTime 2022年8月30日 下午5:47:47
 */
public interface RedisDistributeLock {
	/**
	 * 
	* @Description: 加锁 
	* @Author: liulianglin
	* @Datetime: 2022年8月30日 下午5:49:43
	* @param key 主键
	* @param timeout 超时时间
	* @param unit	 超时时间单位
	* @return boolean  true:加锁成功;false:加锁失败
	* @throws
	 */
	boolean tryLock(String key, long timeout, TimeUnit unit);
	
	/**
	 * 
	* @Description: 释放锁。加锁和释放锁的线程必须保证是同一个。 
	* @Author: liulianglin
	* @Datetime: 2022年8月30日 下午5:51:20
	* @param key 	主键
	* @throws
	 */
	void releaseLock(String key);
}

 

2.2 接口实现

         实现RedisDistributeLock接口，其中针对分布式锁的一些特性进行实现，如加锁解锁线程一致性保证、可重入、非阻塞等（参考注释）

package com.example.demo.redis.lock;
 
import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
 
 
public class RedisDistributeLockImpl implements RedisDistributeLock{
 
	@Autowired
	private StringRedisTemplate stringRedisTemplate;
	
	private ThreadLocal<String> threadLocal = new ThreadLocal<String>();
	
	// 计数器
	private ThreadLocal<Integer> counterThreadLocal = new ThreadLocal<Integer>();
	
	@Override
	public boolean tryLock(String key, long timeout, TimeUnit unit) {
		Boolean isLocked = false;
		if (Objects.isNull(threadLocal.get())) {
			String uuid = UUID.randomUUID().toString();
			threadLocal.set(uuid);
			isLocked = stringRedisTemplate.opsForValue().setIfAbsent(key, uuid, timeout, unit);
			// 如果获取锁失败，通过自旋尝试获取锁，
			if (!isLocked) {
				for (;;) {
					isLocked = stringRedisTemplate.opsForValue().setIfAbsent(key, uuid, timeout, unit);
					if (isLocked) {
						// 获取成功立即退出
						break;
					}
				}
			}
			
			/*
			 *  启动一个线程扮演“看门狗”的角色，不断更新锁索过期时间
			 *  
			 *  注意：这里将stringRedisTemplate对象传给看门狗
			 */
			new Thread(new WatchDogThread(uuid, stringRedisTemplate, key)).start();
		} else {
			isLocked = true;
		}
		
		// 加锁成功后
		if (isLocked) {
			Integer curCount = counterThreadLocal.get() == null ? 0 : counterThreadLocal.get();
			counterThreadLocal.set(curCount++);
		}
		return isLocked;
	}
 
	@Override
	public void releaseLock(String key) {
		// 保证解锁和加锁线程是同一个,防止避免了一个线程对程序进行了加锁操作后，其他线程对这个锁进行了解锁操作的问题
		String uuid = stringRedisTemplate.opsForValue().get(key);
		if (!Objects.isNull(threadLocal.get()) && 
				threadLocal.get().equals(uuid)) {
			Integer curCount = counterThreadLocal.get();
			if (Objects.isNull(curCount) || (--curCount)<=0) {
				stringRedisTemplate.delete(key);
				// 获取对应的看门狗线程的ID
				String watchDogThreadIdStr = stringRedisTemplate.opsForValue().get(uuid);
				// 获取看门狗
				Thread watchDogThread = ThreadUtils.getThreadByThreadId(Long.valueOf(watchDogThreadIdStr));
				
				if (!Objects.isNull(watchDogThread)) {
					// 终端看门狗
					watchDogThread.interrupt();
					stringRedisTemplate.delete(uuid);
				}
			} 
		}
	}
}

 

2.3 看门狗线程

        看门狗线程，更新锁的超时时间，保证锁的释放一定是在加锁线程业务代码执行完毕之后，
防止在业务处理过程中锁超时失效，其他线程依旧能够获取到锁。

package com.example.demo.redis.lock;
 
import java.util.concurrent.TimeUnit;
 
import org.springframework.data.redis.core.StringRedisTemplate;
 
/**
 * 
* @ClassName: WatchDogThread
* @Description: 看门狗线程，更新锁的超时时间，保证锁的释放一定是在加锁线程业务代码执行完毕之后，
* 				防止在业务处理过程中锁超时失效，其他线程依旧能够获取到锁。
* @Author: liulianglin
* @DateTime 2022年8月31日 上午9:33:07
 */
public class WatchDogThread implements Runnable{
	private String uuid;
	private String key;
	private StringRedisTemplate stringRedisTemplate;
	
	
	public WatchDogThread(String uuid, StringRedisTemplate stringRedisTemplate, String key) {
		this.uuid = uuid;
		this.stringRedisTemplate = stringRedisTemplate;
		this.key = key;
	}
	
	@Override
	public void run() {
		/*
		 *  以uuid为key，将当前线程的ID作为value保存到Redis中
			在RedisDistributeLockImpl删除锁时需要通过uuid获取到当前线程ID，然后停止当前看门狗线程。
		 */
		stringRedisTemplate.opsForValue().set(uuid, String.valueOf(Thread.currentThread().getId()));
		
		// 循环更新所的过期时间
		while(true) {
			stringRedisTemplate.expire(key, 10, TimeUnit.SECONDS);
			try {
				// 每秒执行1次
				TimeUnit.SECONDS.sleep(1);
			}catch(InterruptedException e) {
				e.printStackTrace();
			}
		}
		
	}
	
}

2.4 线程操作工具类

        主要是通过线程ID获取线程，目前只有一个方法，比较简单

package com.example.demo.redis.lock;
 
public class ThreadUtils {
	
	/**
	 * 
	* @Description: 通过ThreadID获取线程对象 
	* @Author: liulianglin
	* @Datetime: 2022年8月31日 上午10:00:54
	* @param threadId
	* @return Thread
	* @throws
	 */
	public static Thread getThreadByThreadId(long threadId) {
		ThreadGroup group = Thread.currentThread().getThreadGroup();
        while(group != null) {
            Thread[] threads = new Thread[(int)(group.activeCount() * 1.2)];
            int count = group.enumerate(threads, true);
            for(int i = 0; i < count; i++) {
                if(threadId == threads[i].getId()) {
                    return threads[i];
                }
            }
            group = group.getParent();
        }
        return null;
	}
}

 

 完毕。。。。