分布式锁解决方案

已于 2023-03-23 16:31:09 修改
阅读量455 收藏
点赞数
分类专栏： redis zookeeper 文章标签： redis zookeeper
于 2019-03-26 04:23:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25432245/article/details/88811050
版权

锁:

      单进程的系统中，存在多线程同时操作一个公共变量，此时需要加锁对变量进行同步操作，保证多线程的操作线性执行消除并发修改。解决的是单进程中的多线程并发问题。

分布式锁:

      只要的应用场景是在集群模式的多个相同服务，可能会部署在不同机器上，解决进程间安全问题，防止多进程同时操作一个变量或者数据库。解决的是多进程的并发问题。

JVM有锁的感念（局限于同一台java虚拟机）

一：分布式锁具备的条件：

           1，在分布式系统环境下，一个方法在同一时间只能被一个机器的一个线程执行；

           2，具备可重入特性；

          3，具备锁失效机制，防止死锁；

          4，具备非阻塞锁特性，即如果没有获取到锁直接返回获取锁失败。

二：分布式锁的实现方式

       1，基于缓存（redis）实现分布式锁(共享锁)；

              1.1，redis有很高的性能； 
              1.2，redis命令对此支持较好，实现起来比较方便.                   

/**
 * redis 分布式锁
 * @author reyco
 *
 */
public class DistributedLock {

	private JedisPool jedisPool;

	public DistributedLock(JedisPool jedisPool) {
		super();
		this.jedisPool = jedisPool;
	}
	
	/**
	 * 获取锁
	 * 
	 * @param lockName
	 *            锁的名称
	 * @param acquireTimeout
	 *            获取锁的超时时间,单位毫秒数
	 * @param timeout
	 *            key的超时时间,单位毫秒数
	 */
	public String lock(String lockName, long acquireTimeout, long timeout) {
		Jedis jedis = null;
		// 返回标识
		String identifier = null;
		try {
			jedis = jedisPool.getResource();
			// key
			String lockKey = "lock_" + lockName;
			// key所对应的value值
			String lockValue = UUID.randomUUID().toString();
			// 计算key的超时时间
			Integer expireTime = (int) timeout / 1000;
			// 获取锁的超时时间
			long end = System.currentTimeMillis() + acquireTimeout;
			// 循环获取锁
			while (System.currentTimeMillis() <= end) {
				// key是否存在
				if (jedis.setnx(lockKey, lockValue) == 1) {
					// 如果不存在，设置key过期时间
					jedis.expire(lockKey, expireTime);
					identifier = lockValue;
					return identifier;
				}
				// 如果设置过期时间异常，那么下一次必须设置key过期时间，否则可能出现死锁
				if (jedis.ttl(lockKey) == -1) {
					jedis.expire(lockKey, expireTime);
				}
				// 设置一个时间间隔，避免频繁尝试获取锁
				Thread.sleep(20);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return identifier;
	}
    /**
	 * 手动释放锁
	 * 
	 * @param lockName
	 * 			锁的名称
	 */
	public boolean unlock(String lockName,String lockValue) {
		try {
			// key
			String lockKey = "lock_" + lockName;
			while(jedis.exists(lockKey)) {
				jedis.watch(lockKey);
				if(lockValue.equals(jedis.get(lockKey))) {
					Transaction transaction = jedis.multi();
					// 手动删除key,释放锁
					transaction.del(lockKey);
					List<Object> execQueue = transaction.exec();
					if(execQueue != null) {
						return true;
					}
				}
				jedis.unwatch();
				break;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return false;
	} 
	
/**
 * @author reyco
 * @date 2021年3月18日---下午5:14:56
 * 
 *       <pre>
 *       redis锁实现
 * 
 *       <pre>
 */
@Component
public class RedisLock implements DistributedLock {

	protected Logger logger = LoggerFactory.getLogger(this.getClass());
	
	public final static String SET_LUA_SCRIPT = "if redis.call('setnx', KEYS[1],ARGV[1]) == 1 then return redis.call('EXPIRE',KEYS[1],ARGV[2]) else return 0 end";// lua脚本，用来获取分布式锁
	
	public final static String DEL_LUA_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";// lua脚本，用来释放分布式锁
	
	public final static String RENEWAL_LUA_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('EXPIRE',KEYS[1],ARGV[2]) else return 0 end";// lua脚本，用来续约过期时间
	@Autowired
	@Qualifier("distributedLockThread")
	ExecutorService executorService;
	
	/**
	 * 当前线程锁信息
	 */
	private ThreadLocal<LockInfo> lockInfoThreadLocal = new ThreadLocal<>();
	/**
	 * 锁的key
	 */
	private static final String DISTRIBUTED_LOCK_KEY = "distributedLock:";
	/**
	 * key的名称
	 */
	private static final String DISTRIBUTED_LOCK_DEFAULT = "default";
	/**
	 * 锁的超时时间,默认3000
	 */
	private static final Integer DISTRIBUTED_LOCK_EXPIRE = 3000;

	@Autowired
	private StringRedisTemplate redisTemplate;

	@Override
	public void lock() {
		LockInfo lockInfo = new LockInfo(DISTRIBUTED_LOCK_KEY+DISTRIBUTED_LOCK_DEFAULT, SnowFlake.getNextId().toString(), DISTRIBUTED_LOCK_EXPIRE);
		lockInfoThreadLocal.set(lockInfo);
		List<String> keys = new ArrayList<>();
		keys.add(lockInfo.getLockKey());
		String valueExpireTime = (lockInfo.getExpireTime()/1000)+"";
		DefaultRedisScript<Long> defaultRedisScript = new DefaultRedisScript<>(SET_LUA_SCRIPT,Long.class);
		while(redisTemplate.execute(defaultRedisScript,keys,lockInfo.getLockValue(),valueExpireTime).intValue()==0) {
			try {
				TimeUnit.MILLISECONDS.sleep(lockInfo.getExpireTime()/10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		logger.debug("加锁成功,【key:" +lockInfo.getLockKey() + "】,【value:" + lockInfo.getLockValue() + "】,【expireTimeSecond："+lockInfo.getExpireTime()+"】");
		// 招一个看门狗
		executorService.execute(new Runnable() {
			@Override
			public void run() {
				while(lockInfo.getLockValue().equals(redisTemplate.opsForValue().get(lockInfo.getLockKey()))) {
					List<String> keys = new ArrayList<>();
					keys.add(lockInfo.getLockKey());
					DefaultRedisScript<Long> defaultRedisScript = new DefaultRedisScript<>(RENEWAL_LUA_SCRIPT,Long.class);
					Long result = redisTemplate.execute(defaultRedisScript,keys,lockInfo.getLockValue(),valueExpireTime);
					if(result.intValue()==1) {
						logger.debug("续约成功,【key:" +lockInfo.getLockKey() + "】,【value:" + lockInfo.getLockValue() + "】,【expireTimeSecond："+lockInfo.getExpireTime()+"】");
					}
					try {
						Thread.sleep(lockInfo.getExpireTime()/3);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		});
	}
	@Override
	public void unlock() {
		LockInfo lockInfo = lockInfoThreadLocal.get();
		lockInfoThreadLocal.remove();
		List<String> keys = new ArrayList<>();
		keys.add(lockInfo.getLockKey());
		DefaultRedisScript<Long> defaultRedisScript = new DefaultRedisScript<>(DEL_LUA_SCRIPT,Long.class);
		Long integer = redisTemplate.execute(defaultRedisScript,keys,lockInfo.getLockValue());
		if(integer.intValue()==1) {
			logger.debug("解锁成功,【key:" +lockInfo.getLockKey() + "】,【value:" + lockInfo.getLockValue() + "】");
		}
	}
	
	/**
	 * 加锁
	 * 
	 * @param lockKey
	 *            锁的lockKey
	 * @param lockValue
	 *            锁的value值
	 * @param expireTime
	 *            过期时间
	 */
	@Override
	public void lock(String lockKey, String lockValue, int expireTime) {
		List<String> keys = new ArrayList<>();
		keys.add(lockKey);
		String valueExpireTime = (expireTime/1000)+"";
		DefaultRedisScript<Long> setDefaultRedisScript = new DefaultRedisScript<>(SET_LUA_SCRIPT,Long.class);
		while(redisTemplate.execute(setDefaultRedisScript,keys,lockValue,valueExpireTime).intValue()==0) {
			try {
				Thread.sleep(expireTime/10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		logger.debug("加锁成功,【key:"+lockKey+"】,【value:"+lockValue+"】,【expireTime:"+expireTime+"】");
		//获取锁成功：招一个看门狗
		new Thread(new Runnable() {
			@Override
			public void run() {
				while(lockValue.equals(redisTemplate.opsForValue().get(lockKey))) {
					List<String> keys = new ArrayList<>();
					keys.add(lockKey);
					DefaultRedisScript<Long> renDefaultRedisScript = new DefaultRedisScript<>(RENEWAL_LUA_SCRIPT,Long.class);
					Long result = redisTemplate.execute(renDefaultRedisScript,keys,lockValue,valueExpireTime);
					if(result.intValue()==1) {
						logger.debug("续约成功,【key:"+lockValue+ "】,【value:"+lockValue+"】,【expireTimeSecond："+valueExpireTime+"】");
					}
					try {
						Thread.sleep(expireTime/3);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}).start();
	}
	/**
	 * 解锁
	 * @param lockKey
	 * @param lockValue
	 */
	@Override
	public void unLock(String lockKey, String lockValue) {
		List<String> keys = new ArrayList<>();
		keys.add(lockKey);
		DefaultRedisScript<Long> delDefaultRedisScript = new DefaultRedisScript<>(DEL_LUA_SCRIPT,Long.class);
		Long integer = redisTemplate.execute(delDefaultRedisScript,keys,lockValue);
		if(integer.intValue()==1) {
			logger.debug("解锁成功,【key:" +lockKey + "】,【value:" + lockValue + "】");
		}
	}

	@Override
	public void lockInterruptibly() throws InterruptedException {
	}

	@Override
	public boolean tryLock() {
		return false;
	}

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

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

	/**
	 * 锁信息
	 * 
	 * @author reyco
	 *
	 */
	static class LockInfo {
		private String lockKey;
		private String lockValue;
		private Integer expireTime;

		public LockInfo(String lockKey, String lockValue, Integer expireTime) {
			super();
			this.lockKey = lockKey;
			this.lockValue = lockValue;
			this.expireTime = expireTime;
		}

		public String getLockKey() {
			return lockKey;
		}

		public void setLockKey(String lockKey) {
			this.lockKey = lockKey;
		}

		public String getLockValue() {
			return lockValue;
		}

		public void setLockValue(String lockValue) {
			this.lockValue = lockValue;
		}

		public Integer getExpireTime() {
			return expireTime;
		}

		public void setExpireTime(Integer expireTime) {
			this.expireTime = expireTime;
		}
	}
}


      2，基于Zookeeper实现分布式锁；

                     2.1，使用zk的临时节点特性失效分布式锁；

                          2.1.1，采用临时节点实现分布式锁（互斥锁);

                                     将zookeeper上的一个znode看作是一把锁，所有客户端都去创建/distribute_lock 节点，最终成功创建的   那个客户端也即拥有了这把锁。用完删除掉自己创建的/distribute_lock节点就释放出锁。没有获取到锁的客 户端等待，对/distribute_lock节点watcher删除监听，如果监听到 /distribute_lock节点删除，所有客户端去争取获取锁，没有获取到锁的客户端继续监听。

                                     这种实现方式有羊群问题，会出现死锁问题.  如：监听客户端很多，所有客户端争抢锁，会出现网络阻    塞；获取锁的客户端没有及时的删除节点，所有客户端一直等待，会出现死锁问题。 

                          2.1.2，采用临时顺序节点实现分布式锁：超时机制+临时顺序节点（共享锁).

                                           /distribute_lock 已经预先存在，所有客户端在它下面创建临时顺序编号目录节点，编号最小的获得      锁，用完删除，依次方便。

                                    a，在约定的节点下面创建/distribute_lock节点；

                                    b，所有客户端在/distribute_lock节点下创建自己的临时顺序节点；

                                    c，所有客户端需要获取锁；

                                              先对所有临时顺序节点排序，然后尝试获取锁。如果获取锁，正常执行，如果没有获取到锁，监听比自己次小的节点的删除事件。

                                      此种实现方案有bug：如果中间客户端出现网络故障或宕机，就会出现多个客户端获取锁的bug。

            

/**
 * Zookeeper 超时机制+临时节点
 * 
 * @author reyco
 *
 */
public class DistributedLock implements Lock {
	//private static final String ZK_ADDRESS = "192.168.2.107:2181,192.168.2.108:2181,192.168.2.110:2181";
    private static final String ZK_ADDRESS = "192.168.241.123:2181,192.168.241.124:2181,192.168.241.125:2181";
	/**
	 * 父节点
	 */
	private String distributedLock = "/distributedLock";
	/**
	 * 子节点
	 */
	private static final String LOCKNAME = "/lock_";
	/**
	 * 当前节点
	 */
	private static ThreadLocal<String> currentPath = new ThreadLocal<>();
	/**
	 * 前一个节点
	 */
	private static ThreadLocal<String> beforePath = new ThreadLocal<>();
	/**
	 * zkc
	 */
	private ZkClient zkClient;
	/**
	 * 超时时间
	 */
	private static final int TIMIOUT = 5000;

	/**
	 * 
	 * @param rootPath
	 */
	public DistributedLock(String rootPath) {
		this.distributedLock = rootPath;
		zkClient = new ZkClient(new ZkConnection(ZK_ADDRESS, TIMIOUT));
		if (!zkClient.exists(distributedLock)) {
			zkClient.createPersistent(distributedLock);
		}
		zkClient.setZkSerializer(new ZkSerializer() {
			@Override
			public byte[] serialize(Object data) throws ZkMarshallingError {
				return String.valueOf(data).getBytes();
			}
			@Override
			public Object deserialize(byte[] bytes) throws ZkMarshallingError {
				return new String(bytes);
			}
		});
	}

	@Override
	public void lock() {
		// 尝试获取锁
		if (!tryLock()) {
			// 等待
			waitForLock();
			// 获取锁
			lock();
		}
	}

	/**
	 * 
	 */
	private void waitForLock() {
		CountDownLatch countDownLatch = new CountDownLatch(1);
		// 注册监听
		IZkDataListener listener = new IZkDataListener() {
			@Override
			public void handleDataDeleted(String dataPath) throws Exception {
				System.out.println(Thread.currentThread().getName()+",监听节点被删除。。。" + dataPath);
				countDownLatch.countDown();
			}
			@Override
			public void handleDataChange(String dataPath, Object data) throws Exception {
				System.out.println("监听节点数据变化。。。" + data);
			}
		};
		zkClient.subscribeDataChanges(this.beforePath.get(), listener);
		try {
			if (this.zkClient.exists(this.beforePath.get())) {
				countDownLatch.await();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		zkClient.unsubscribeDataChanges(this.beforePath.get(), listener);
	}

	@Override
	public void lockInterruptibly() throws InterruptedException {

	}

	/**
	 * 尝试获取锁
	 */
	@Override
	public boolean tryLock() {
		// 如果存在就不创建了
		if (null == this.currentPath.get()) {
			// 创建临时顺序节点
			currentPath.set(this.zkClient.createPersistentSequential(distributedLock + LOCKNAME, "lockName"));
		}
		// 获取所有子节点
		List<String> children = this.zkClient.getChildren(distributedLock);
		// 排序children
		Collections.sort(children);
		// 判断是否最小节点
		if (currentPath.get().equals(distributedLock + "/" + children.get(0))) {
			return true;
		}
		// 获取前一个节点
		else {
			// 获取当前节点的索引号
			int currentIndex = children.indexOf(currentPath.get().substring(distributedLock.length()+1));
			beforePath.set(distributedLock + "/"+children.get(currentIndex - 1));
		}
		return false;
	}

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

	@Override
	public void unlock() {
		zkClient.delete(this.currentPath.get());
	}

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

	/**
	 * 测试
	 * @param args
	 * @throws InterruptedException
	 */
	public static void main(String[] args) throws InterruptedException {
		String path =  "/distributedLock";
		List<String> list = new ArrayList<>();
		int threadSize = 20;
		CountDownLatch countDownLatch = new  CountDownLatch(threadSize);
		ExecutorService threadPool = Executors.newFixedThreadPool(threadSize);
		for (int i = 0; i < threadSize; i++) {
			threadPool.execute(new Runnable() {
				@Override
				public void run() {
					DistributedLock distributedLock = new DistributedLock(path);
					try {
						distributedLock.lock();
						list.add("asdw ");
						countDownLatch.countDown();
					} catch (Exception e) {
						e.printStackTrace();
					}finally {
						distributedLock.unlock();
					}
				}
			});
		}
		countDownLatch.await();
		threadPool.shutdown();
		System.out.println(list.size());
	}
}

                     2，解决zk临时顺序节点分布式锁的bug，采用：超时机制+永久节点 实现分布式锁（共享锁）。                                                               重构一个类似redis-ping-pong：永久顺序节点写入(客户端ip+port)，判断获取锁的节点是否能正常工作，如果能正常工作就让其正常执行业务，执行业务后删除节点；如果不能正常工作就直接删除这个节点。

java的艺术
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
看完这篇分布式锁，再也不迷惑了
weixin_46906359的博客
03-11 869
分布式锁介绍
为何要用分布式锁&Redis实现分布式锁
QRLYLETITBE的博客
06-04 1166
为何要用分布式锁&Redis实现分布式锁
【Redis】分布式锁及其他常见问题
Carefree_State的博客
04-04 1090
一定要结合业务场景来回答问题！要是没有不要硬讲，除非面试官问；接下来面试官将深入发问。分布式情况下的，或者集群情况下的，多个微服务操作同一对象，可能是相同操作（同时改），也可能是不同操作（一个删，一个改…）
分布式.分布式锁
记录 分享 成就
07-27 3013
有一个公共厕所只有一个坑位，为了控制正在使用的人不被使用，旁边设置了个门房，并给厕所上了，只有拿到的人才可以使用。如果多人(多台机器，多个线程等)操作一个单元，那么结果就可能不是谁都愿意看到的。这是同步问题，放在分布式中也一样，解决方案就是有一个尽可能小的单线程中间变量作为是否可以该变量的标记。谁拿到这把钥匙，谁就可以开启箱子。...
必须掌握【分布式锁】三种实现方式
田维常
05-10 1030
点击上方↑↑↑“Java后端技术栈”关注我们一、为什么要使用分布式锁我们在开发应用的时候，如果需要对某一个共享变量进行多线程同步访问的时候，可以使用我们学到的Java多线程的18般武艺进...
分布式共享锁
weixin_34184158的博客
01-12 105
11.1 需求描述 在我们自己的分布式业务系统中，可能会存在某种资源，需要被整个系统的各台服务器共享访问，但是只允许一台服务器同时访问 11.2 设计思路 11.3 代码开发 public class DistributedClientMy { // 超时时间 ...
分布式锁解决方案.docx
10-26
分布式锁解决方案.docx
超卖和分布式锁解决方案.docx
10-26
超卖和分布式锁解决方案.docx
分布式锁与信号量微服务架构中基于MQ的分布式事务解决方案.zip
最新发布
06-10
分布式锁与信号量微服务架构中基于MQ的分布式事务解决方案分布式锁与信号量微服务架构中基于MQ的分布式事务解决方案分布式锁与信号量微服务架构中基于MQ的分布式事务解决方案分布式锁与信号量微服务架构中基于MQ的...
Redis分布式锁解决接口幂等的两种方案
12-21
Redis分布式锁解决接口幂等的两种方案一、背景二、基础知识三、解决方案四、实验五、说在最后的话 一、背景 还在为不了解分布式锁而烦恼吗？还在为众多微服务接口不幂等而发愁吗？如果是，并且有兴趣同我一起学习，...
Redis分布式锁存在的问题及解决方案（值得珍藏）
01-20
Redis分布式锁在实现跨进程、跨机器的互斥访问时，虽功能强大，但也存在一些常见问题。这些问题主要源于网络延迟、...总之，正确使用Redis分布式锁需深入理解其工作原理和潜在问题，并结合实际场景选择合适的解决方案。
Redis分布式锁
m0_61495361的博客
11-11 457
Redis分布式锁
分布式锁学习详解
qq_45228323的博客
12-20 500
1. 分布式锁 1.1 什么是分布式锁 在我们进行单机应用开发涉及并发同步的时候，我们往往采用synchronized或者ReentrantLock的方式来解决多线程间的代码同步问题。但是当我们的应用是在分布式集群工作的情况下，那么就需要一种更加高级的锁机制，来处理种跨机器的进程之间的数据同步问题，这就是分布式锁。 分布式锁，是控制分布式系统之间同步访问共享资源的一种方式。在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要
分布式之抉择分布式锁
derek2538的博客
07-24 889
引言 为什么写这篇文章？ 目前网上大部分的基于zookeeper，和redis的分布式锁的文章都不够全面。要么就是特意避开集群的情况，要么就是考虑不全，读者看着还是一脸迷茫。坦白说，这种老题材，很难写出新创意，博主内心战战兢兢，如履薄冰，文中有什么不严谨之处，欢迎批评。 博主的这篇文章，不上代码，只讲分析。 (1)在redis方面，有开源redisson的jar包供你使用。 ...
多线程写文件以及分布式锁实现
huangdi1309的博客
01-12 956
有一天梦见女朋友跟一个陌生男人逛街，我很是着急，于是有很多志同道合的朋友开始为我出谋划策。有说，让那个男的指向null，让垃圾回收他。 也有的说给个死循环，让他们逛到累，累死他们。。。没错，你们说的都有道理，但是，如果换是我，我会给自己女朋友逛街这个行为上锁，并且只有我才能获取到锁，也不会把锁让给别人。好了，扯完，开始进入正题，没错，就是锁。 在开发过程中往往会遇到大量数据请求，并且需要快速响应...
Zookeeper分布式共享锁
weixin_41126842的博客
06-07 464
zookeeper实现分布式共享锁逻辑： 1.程序节点启动时到zookeeper上注册一个“短暂+序号”的znode,并监听父节点（详情：Zookeeper：用客户端对Zookeeper进行操作） 2.获取父节点下的所有程序子节点，比较序号大小 3.序号最小的获取到“锁”，去访问资源，访问完后，删除自己的节点，相当于释放锁，并且重新注册一个新的节点 4.其他程序会受到事件通知，则...
java使用redis分布式锁
微信公众号：一颗向上的草莓
07-25 721
1、背景 目前在查询时并发量较高，qps 6000左右，数据查出来后缓存在redis中，有效期5分钟，为防止redis失效的瞬间有太多到达数据库，给数据库造成冲击，在查询时使用redis分布式锁，保证一种查询条件只有一个查询能请求到数据库。 2、使用 2.1引入jedis <!--jedis--> <dependency> <groupId>redis.clients</groupId> <artifactId>jed
RedLock
banwh的博客
04-17 255
Redlock实现 假设有N个Redis master。这些节点完全互相独立，不存在主从复制或者其他集群协调机制。我们确保将在N个实例上使用与在Redis单实例下相同方法获取和释放锁。现在我们假设有5个Redis master节点，同时我们需要在5台服务器上面运行这些Redis实例，这样保证他...
springboot集成redis分布式锁
lgy_lucky的博客
11-24 252
目前，大多数服务都是用了多实例，集群部署。传统的synchronized，ReentrantLock等锁，只能在单实例内部生效。集群服务的线程安全，需要通过分布式锁实现，当然如果是数据库访问的话，也可以通过数据库实现锁（TODO: mysql集群行锁能否在分布式服务中生效？需要再探究下）。本篇文章主要介绍在springboot项目中使用redis实现分布式锁。 1.StringRedisTemplate实现分布式锁 1.1pom.xml文件引入redis依赖 <dependency>..
jedis rediscluster 分布式锁
01-15
jedis是一个用java语言编写的分布式Redis Java客户端工具，它可以...总的来说，jedis和RedisCluster提供了方便且高效的分布式锁解决方案，但在实际使用中还需要谨慎处理各种异常情况，以确保分布式锁的可靠性和稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

java的艺术

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值