当前位置：首页 > 单片机 > 架构师社区

分布式锁的三种实现方式

时间：2020-08-19 09:48:03
关键字： 分布式   
手机看文章

扫描二维码
随时随地手机看文章

[导读]1. 基于数据库实现分布式锁； 2. 基于缓存（Redis等）实现分布式锁； 3. 基于Zookeeper实现分布式锁。


作者：BarryWang

www.cnblogs.com/barrywxx/p/11644803.html


分布式锁三种实现方式：

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

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

3. 基于Zookeeper实现分布式锁；

一， 基于数据库实现分布式锁

 

1. 悲观锁

利用select … where … for update 排他锁

注意: 其他附加功能与实现一基本一致，这里需要注意的是“where name=lock ”，name字段必须要走索引，否则会锁表。有些情况下，比如表不大，mysql优化器会不走这个索引，导致锁表问题。

 

2. 乐观锁

所谓乐观锁与前边最大区别在于基于CAS思想，是不具有互斥性，不会产生锁等待而消耗资源，操作过程中认为不存在并发冲突，只有update version失败后才能觉察到。我们的抢购、秒杀就是用了这种实现以防止超卖。
通过增加递增的版本号字段实现乐观锁

分布式锁的三种实现方式

 

二， 基于缓存（Redis等）实现分布式锁

 

1. 使用命令介绍：
（1）SETNX
SETNX key val：当且仅当key不存在时，set一个key为val的字符串，返回1；若key存在，则什么都不做，返回0。
（2）expire
expire key timeout：为key设置一个超时时间，单位为second，超过这个时间锁会自动释放，避免死锁。
（3）delete
delete key：删除key

在使用Redis实现分布式锁的时候，主要就会使用到这三个命令。

 

2. 实现思想：
（1）获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过此在释放锁的时候进行判断。
（2）获取锁的时候还设置一个获取的超时时间，若超过这个时间则放弃获取锁。
（3）释放锁的时候，通过UUID判断是不是该锁，若是该锁，则执行delete进行锁释放。

 

3. 分布式锁的简单实现代码：

/** * 分布式锁的简单实现代码 4 */public class DistributedLock {
 private final JedisPool jedisPool;
 public DistributedLock(JedisPool jedisPool) { this.jedisPool = jedisPool; }
 /** * 加锁 * @param lockName 锁的key * @param acquireTimeout 获取超时时间 * @param timeout 锁的超时时间 * @return 锁标识 */ public String lockWithTimeout(String lockName, long acquireTimeout, long timeout) { Jedis conn = null; String retIdentifier = null; try { // 获取连接 conn = jedisPool.getResource(); // 随机生成一个value String identifier = UUID.randomUUID().toString(); // 锁名，即key值 String lockKey = "lock:" + lockName; // 超时时间，上锁后超过此时间则自动释放锁 int lockExpire = (int) (timeout / 1000);
 // 获取锁的超时时间，超过这个时间则放弃获取锁 long end = System.currentTimeMillis() + acquireTimeout; while (System.currentTimeMillis() < end) { if (conn.setnx(lockKey, identifier) == 1) { conn.expire(lockKey, lockExpire); // 返回value值，用于释放锁时间确认 retIdentifier = identifier; return retIdentifier; } // 返回-1代表key没有设置超时时间，为key设置一个超时时间 if (conn.ttl(lockKey) == -1) { conn.expire(lockKey, lockExpire); }
 try { Thread.sleep(10); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } catch (JedisException e) { e.printStackTrace(); } finally { if (conn != null) { conn.close(); } } return retIdentifier; }
 /** * 释放锁 * @param lockName 锁的key * @param identifier 释放锁的标识 * @return */ public boolean releaseLock(String lockName, String identifier) { Jedis conn = null; String lockKey = "lock:" + lockName; boolean retFlag = false; try { conn = jedisPool.getResource(); while (true) { // 监视lock，准备开始事务 conn.watch(lockKey); // 通过前面返回的value值判断是不是该锁，若是该锁，则删除，释放锁 if (identifier.equals(conn.get(lockKey))) { Transaction transaction = conn.multi(); transaction.del(lockKey); List results = transaction.exec(); if (results == null) { continue; } retFlag = true; } conn.unwatch(); break; } } catch (JedisException e) { e.printStackTrace(); } finally { if (conn != null) { conn.close(); } } return retFlag; }}
  
  
 

  
4. 测试刚才实现的分布式锁

  
例子中使用50个线程模拟秒杀一个商品，使用–运算符来实现商品减少，从结果有序性就可以看出是否为加锁状态。

  
模拟秒杀服务，在其中配置了jedis线程池，在初始化的时候传给分布式锁，供其使用。

  

   
    
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
   

   
public class Service {
 private static JedisPool pool = null;
 private DistributedLock lock = new DistributedLock(pool);
 int n = 500;
 static { JedisPoolConfig config = new JedisPoolConfig(); // 设置最大连接数 config.setMaxTotal(200); // 设置最大空闲数 config.setMaxIdle(8); // 设置最大等待时间 config.setMaxWaitMillis(1000 * 100); // 在borrow一个jedis实例时，是否需要验证，若为true，则所有jedis实例均是可用的 config.setTestOnBorrow(true); pool = new JedisPool(config, "127.0.0.1", 6379, 3000); }
 public void seckill() { // 返回锁的value值，供释放锁时候进行判断 String identifier = lock.lockWithTimeout("resource", 5000, 1000); System.out.println(Thread.currentThread().getName() + "获得了锁"); System.out.println(--n); lock.releaseLock("resource", identifier); }}

  

  
 

  
模拟线程进行秒杀服务;

  

   
    
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
   

   
public class ThreadA extends Thread { private Service service;
 public ThreadA(Service service) { this.service = service; }
 @Override public void run() { service.seckill(); }}
public class Test { public static void main(String[] args) { Service service = new Service(); for (int i = 0; i < 50; i++) { ThreadA threadA = new ThreadA(service); threadA.start(); } }}

  

  
结果如下，结果为有序的：

  
分布式锁的三种实现方式

  
若注释掉使用锁的部分：

  

   
    
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
   

   
public void seckill() { // 返回锁的value值，供释放锁时候进行判断 //String indentifier = lock.lockWithTimeout("resource", 5000, 1000); System.out.println(Thread.currentThread().getName() + "获得了锁"); System.out.println(--n); //lock.releaseLock("resource", indentifier);}

  

  
从结果可以看出，有一些是异步进行的：

  
分布式锁的三种实现方式

  
 

  
三， 基于Zookeeper实现分布式锁

  
 

  
ZooKeeper是一个为分布式应用提供一致性服务的开源组件，它内部是一个分层的文件系统目录树结构，规定同一个目录下只能有一个唯一文件名。基于ZooKeeper实现分布式锁的步骤如下：

  
（1）创建一个目录mylock；
（2）线程A想获取锁就在mylock目录下创建临时顺序节点；
（3）获取mylock目录下所有的子节点，然后获取比自己小的兄弟节点，如果不存在，则说明当前线程顺序号最小，获得锁；
（4）线程B获取所有节点，判断自己不是最小节点，设置监听比自己次小的节点；
（5）线程A处理完，删除自己的节点，线程B监听到变更事件，判断自己是不是最小的节点，如果是则获得锁。

  
这里推荐一个Apache的开源库Curator，它是一个ZooKeeper客户端，Curator提供的InterProcessMutex是分布式锁的实现，acquire方法用于获取锁，release方法用于释放锁。

  
实现源码如下：

  

   
    
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
    
  • 
   

   
import lombok.extern.slf4j.Slf4j;import org.apache.commons.lang.StringUtils;import org.apache.curator.framework.CuratorFramework;import org.apache.curator.framework.CuratorFrameworkFactory;import org.apache.curator.retry.RetryNTimes;import org.apache.zookeeper.CreateMode;import org.apache.zookeeper.data.Stat;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.Bean;import org.springframework.stereotype.Component;
/** * 分布式锁Zookeeper实现 * */@Slf4j@Componentpublic class ZkLock implements DistributionLock {private String zkAddress = "zk_adress"; private static final String root = "package root"; private CuratorFramework zkClient;
 private final String LOCK_PREFIX = "/lock_";
 @Bean public DistributionLock initZkLock() { if (StringUtils.isBlank(root)) { throw new RuntimeException("zookeeper 'root' can't be null"); } zkClient = CuratorFrameworkFactory .builder() .connectString(zkAddress) .retryPolicy(new RetryNTimes(2000, 20000)) .namespace(root) .build(); zkClient.start(); return this; }
 public boolean tryLock(String lockName) { lockName = LOCK_PREFIX+lockName; boolean locked = true; try { Stat stat = zkClient.checkExists().forPath(lockName); if (stat == null) { log.info("tryLock:{}", lockName); stat = zkClient.checkExists().forPath(lockName); if (stat == null) { zkClient .create() .creatingParentsIfNeeded() .withMode(CreateMode.EPHEMERAL) .forPath(lockName, "1".getBytes()); } else { log.warn("double-check stat.version:{}", stat.getAversion()); locked = false; } } else { log.warn("check stat.version:{}", stat.getAversion()); locked = false; } } catch (Exception e) { locked = false; } return locked; }
 public boolean tryLock(String key, long timeout) { return false; }
 public void release(String lockName) { lockName = LOCK_PREFIX+lockName; try { zkClient .delete() .guaranteed() .deletingChildrenIfNeeded() .forPath(lockName); log.info("release:{}", lockName); } catch (Exception e) { log.error("删除", e); } }
 public void setZkAddress(String zkAddress) { this.zkAddress = zkAddress; }}

  

  
优点：具备高可用、可重入、阻塞锁特性，可解决失效死锁问题。

  
缺点：因为需要频繁的创建和删除节点，性能上不如Redis方式。

  
 

  
四，对比

  

数据库分布式锁实现
缺点：

  
1.db操作性能较差，并且有锁表的风险
2.非阻塞操作失败后，需要轮询，占用cpu资源;
3.长时间不commit或者长时间轮询，可能会占用较多连接资源

  
Redis(缓存)分布式锁实现
缺点：

  
1.锁删除失败 过期时间不好控制
2.非阻塞，操作失败后，需要轮询，占用cpu资源;

  
ZK分布式锁实现
缺点：性能不如redis实现，主要原因是写操作（获取锁释放锁）都需要在Leader上执行，然后同步到follower。

  
总之：ZooKeeper有较好的性能和可靠性。

  
 

  
从理解的难易程度角度（从低到高）数据库 > 缓存 > Zookeeper

  
从实现的复杂性角度（从低到高）Zookeeper >= 缓存 > 数据库

  
从性能角度（从高到低）缓存 > Zookeeper >= 数据库

  
从可靠性角度（从高到低）Zookeeper > 缓存 > 数据库

  
特别推荐一个分享架构+算法的优质内容，还没关注的小伙伴，可以长按关注一下：
分布式锁的三种实现方式
分布式锁的三种实现方式

  
分布式锁的三种实现方式

  
长按订阅更多精彩▼
分布式锁的三种实现方式
如有收获，点个在看，诚挚感谢

  

 
  

免责声明：本文内容由21ic获得授权后发布，版权归原作者所有，本平台仅提供信息存储服务。文章仅代表作者个人观点，不代表本平台立场，如有问题，请联系我们，谢谢！
		
                
		

									 
		

                            
本站声明： 本文章由作者或相关机构授权发布，目的在于传递更多信息，并不代表本站赞同其观点，本站亦不保证或承诺内容真实性等。需要转载请联系该专栏作者，如若文章内容侵犯您的权益，请及时联系本站删除。

        		

			
		


		


		

        
		    

			

				

					
					换一批
				

				
延伸阅读

			

						

														

						
[电子设计自动化]
							
与传统的驱动方式相比，共阴恒流驱动在能效有哪些优势

						

						

							
LED驱动电源的输入包括高压工频交流(即市电)、低压直流、高压直流、低压高频交流(如电子变压器的输出)等。

							关键字：
																驱动电源
															
						

					

																			

						
[电源]
							
工业电机驱动电源设计：反电动势抑制与过流保护的集成方案

						

						

							
在工业自动化蓬勃发展的当下，工业电机作为核心动力设备，其驱动电源的性能直接关系到整个系统的稳定性和可靠性。其中，反电动势抑制与过流保护是驱动电源设计中至关重要的两个环节，集成化方案的设计成为提升电机驱动性能的关键。

							关键字：
																工业电机
																驱动电源
															
						

					

																			

						
[电源]
							
如何解决 LED 驱动电源的易损坏问题

						

						

							
LED 驱动电源作为 LED 照明系统的 “心脏”，其稳定性直接决定了整个照明设备的使用寿命。然而，在实际应用中，LED 驱动电源易损坏的问题却十分常见，不仅增加了维护成本，还影响了用户体验。要解决这一问题，需从设计、生...

							关键字：
																驱动电源
																照明系统
																散热
															
						

					

																			

						
[电力电工电路]
							
LED设计中LED驱动电源的公式

						

						

							
根据LED驱动电源的公式，电感内电流波动大小和电感值成反比，输出纹波和输出电容值成反比。所以加大电感值和输出电容值可以减小纹波。

							关键字：
																LED
																设计
																驱动电源
															
						

					

																			

						
[汽车电子]
							
EV主驱IGBT隔离驱动电源方案选择问题探讨

						

						

							
电动汽车(EV)作为新能源汽车的重要代表，正逐渐成为全球汽车产业的重要发展方向。电动汽车的核心技术之一是电机驱动控制系统，而绝缘栅双极型晶体管(IGBT)作为电机驱动系统中的关键元件，其性能直接影响到电动汽车的动力性能和...

							关键字：
																电动汽车
																新能源
																驱动电源
															
						

					

																			

						
[电源]
							
合理的驱动电源方案成为大功率区域照明的主流选择

						

						

							
在现代城市建设中，街道及停车场照明作为基础设施的重要组成部分，其质量和效率直接关系到城市的公共安全、居民生活质量和能源利用效率。随着科技的进步，高亮度白光发光二极管(LED)因其独特的优势逐渐取代传统光源，成为大功率区域...

							关键字：
																发光二极管
																驱动电源
																LED
															
						

					

																			

						
[消费电子]
							
AC-DC电源转换拓扑结构设计

						

						

							
LED通用照明设计工程师会遇到许多挑战，如功率密度、功率因数校正(PFC)、空间受限和可靠性等。

							关键字：
																LED
																驱动电源
																功率因数校正
															
						

					

																			

						
[电源]
							
针对于LED照明驱动电源技术中的电磁干扰其中的三大硬件问题措施

						

						

							
在LED照明技术日益普及的今天，LED驱动电源的电磁干扰(EMI)问题成为了一个不可忽视的挑战。电磁干扰不仅会影响LED灯具的正常工作，还可能对周围电子设备造成不利影响，甚至引发系统故障。因此，采取有效的硬件措施来解决L...

							关键字：
																LED照明技术
																电磁干扰
																驱动电源
															
						

					

																			

						
[电源]
							
LED驱动电源的核心部分“开关管”和“变换器”设计技巧

						

						

							
开关电源具有效率高的特性,而且开关电源的变压器体积比串联稳压型电源的要小得多,电源电路比较整洁,整机重量也有所下降,所以,现在的LED驱动电源

							关键字：
																LED
																驱动电源
																开关电源
															
						

					

																			

						
[电源]
							
最全LED驱动电源及散热设计方案介绍

						

						

							
LED驱动电源是把电源供应转换为特定的电压电流以驱动LED发光的电压转换器，通常情况下：LED驱动电源的输入包括高压工频交流(即市电)、低压直流、高压直流、低压高频交流(如电子变压器的输出)等。

							关键字：
																LED
																隧道灯
																驱动电源
															
						

					

												


			
            
            

		

            

	



    






	
	

	





    
    

        关闭