博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
分布式锁的三种实现方式
阅读量：4969 次
发布时间：2019-06-12

本文共 9405 字，大约阅读时间需要 31 分钟。

分布式锁大有用途，比如用在减库存操作、流水号生成，分布式计数器等。分布式锁服务在大家的项目中或许用的不多，因为大家都把排他放在数据库那一层来挡。当大量的行锁、表锁、事务充斥着数据库的时候。一般web应用很多的瓶颈都在数据库上，这里给大家介绍的是减轻数据库锁负担的方案--分布式锁服务。本文介绍分布式锁常用的三种实现方式。

 

一、zookeeper

1、实现原理：

基于zookeeper瞬时有序节点实现的分布式锁，其主要逻辑如下（该图来自于IBM网站）。大致思想即为：每个客户端对某个功能加锁时，在zookeeper上的与该功能对应的指定节点的目录下，生成一个唯一的瞬时有序节点。判断是否获取锁的方式很简单，只需要判断有序节点中序号最小的一个。当释放锁的时候，只需将这个瞬时节点删除即可。同时，其可以避免服务宕机导致的锁无法释放，而产生的死锁问题。

2、优点

锁安全性高，zk可持久化

3、缺点

性能开销比较高。因为其需要动态产生、销毁瞬时节点来实现锁功能。

4、实现

可以直接采用zookeeper第三方库curator即可方便地实现分布式锁。以下为基于curator实现的zk分布式锁核心代码：

 

Java代码  
  1. @Override  
  2. public boolean tryLock(LockInfo info) {  
  3.     InterProcessMutex mutex = getMutex(info);  
  4.     int tryTimes = info.getTryTimes();  
  5.     long tryInterval = info.getTryInterval();  
  6.     boolean flag = true;// 代表是否需要重试  
  7.     while (flag && --tryTimes >= 0) {  
  8.         try {  
  9.             if (mutex.acquire(info.getWaitLockTime(), TimeUnit.MILLISECONDS)) {  
  10.                 LOGGER.info(LogConstant.DST_LOCK + "acquire lock successfully!");  
  11.                 flag = false;  
  12.                 break;  
  13.             }  
  14.         } catch (Exception e) {  
  15.             LOGGER.error(LogConstant.DST_LOCK + "acquire lock error!", e);  
  16.         } finally {  
  17.             checkAndRetry(flag, tryInterval, tryTimes);  
  18.         }  
  19.     }  
  20.     return !flag;// 最后还需要重试，说明没拿到锁  
  21. }  

 

Java代码  
  1. @Override  
  2. public boolean releaseLock(LockInfo info) {  
  3.     InterProcessMutex mutex = getMutex(info);  
  4.     int tryTimes = info.getTryTimes();  
  5.     long tryInterval = info.getTryInterval();  
  6.     boolean flag = true;// 代表是否需要重试  
  7.     while (flag && --tryTimes >= 0) {  
  8.         try {  
  9.             mutex.release();  
  10.             LOGGER.info(LogConstant.DST_LOCK + "release lock successfully!");  
  11.             flag = false;  
  12.             break;  
  13.         } catch (Exception e) {  
  14.             LOGGER.error(LogConstant.DST_LOCK + "release lock error!", e);  
  15.         } finally {  
  16.             checkAndRetry(flag, tryInterval, tryTimes);  
  17.         }  
  18.     }  
  19.     return !flag;// 最后还需要重试，说明没拿到锁  
  20. }  

 

Java代码  
  1. /** 
  2.      * 获取锁。此处需要加同步，concurrentHashmap无法避免此处的同步问题 
  3.      * @param info 锁信息 
  4.      * @return 锁实例 
  5.      */  
  6.     private synchronized InterProcessMutex getMutex(LockInfo info) {  
  7.         InterProcessReadWriteLock lock = null;  
  8.         if (locksCache.get(info.getLock()) != null) {  
  9.             lock = locksCache.get(info.getLock());  
  10.         } else {  
  11.             lock = new InterProcessReadWriteLock(client, BASE_DIR + info.getLock());  
  12.             locksCache.put(info.getLock(), lock);  
  13.         }  
  14.         InterProcessMutex mutex = null;  
  15.         switch (info.getIsolate()) {  
  16.         case READ:  
  17.             mutex = lock.readLock();  
  18.             break;  
  19.         case WRITE:  
  20.             mutex = lock.writeLock();  
  21.             break;  
  22.         default:  
  23.             throw new IllegalArgumentException();  
  24.         }  
  25.         return mutex;  
  26.     }  

 

Java代码  
  1. /** 
  2.  * 判断是否需要重试 
  3.  * @param flag 是否需要重试标志 
  4.  * @param tryInterval 重试间隔 
  5.  * @param tryTimes 重试次数 
  6.  */  
  7. private void checkAndRetry(boolean flag, long tryInterval, int tryTimes) {  
  8.     try {  
  9.         if (flag) {  
  10.             Thread.sleep(tryInterval);  
  11.             LOGGER.info(LogConstant.DST_LOCK + "retry getting lock! now retry time left: " + tryTimes);  
  12.         }  
  13.     } catch (InterruptedException e) {  
  14.         LOGGER.error(LogConstant.DST_LOCK + "retry interval thread interruptted!", e);  
  15.     }  
  16. }  

 

二、memcached分布式锁

1、实现原理：

memcached带有add函数，利用add函数的特性即可实现分布式锁。add和set的区别在于：如果多线程并发set，则每个set都会成功，但最后存储的值以最后的set的线程为准。而add的话则相反，add会添加第一个到达的值，并返回true，后续的添加则都会返回false。利用该点即可很轻松地实现分布式锁。

2、优点

并发高效。

3、缺点

（1）memcached采用列入LRU置换策略，所以如果内存不够，可能导致缓存中的锁信息丢失。

（2）memcached无法持久化，一旦重启，将导致信息丢失。

 

三、redis分布式锁

redis分布式锁即可以结合zk分布式锁锁高度安全和memcached并发场景下效率很好的优点，可以利用jedis客户端实现。

/** * @author http://blog.csdn.net/java2000_wl * @version 1.0.0 */public class RedisBillLockHandler implements IBatchBillLockHandler {	private static final Logger LOGGER = LoggerFactory.getLogger(RedisBillLockHandler.class);	private static final int DEFAULT_SINGLE_EXPIRE_TIME = 3;		private static final int DEFAULT_BATCH_EXPIRE_TIME = 6;	private final JedisPool jedisPool;		/**	 * 构造	 * @author http://blog.csdn.net/java2000_wl	 */	public RedisBillLockHandler(JedisPool jedisPool) {		this.jedisPool = jedisPool;	}	/**	 * 获取锁  如果锁可用   立即返回true，  否则返回false	 * @author http://blog.csdn.net/java2000_wl	 * @param billIdentify	 * @return	 */	public boolean tryLock(IBillIdentify billIdentify) {		return tryLock(billIdentify, 0L, null);	}	/**	 * 锁在给定的等待时间内空闲，则获取锁成功 返回true， 否则返回false	 * @author http://blog.csdn.net/java2000_wl	 * @param billIdentify	 * @param timeout	 * @param unit	 * @return	 */	public boolean tryLock(IBillIdentify billIdentify, long timeout, TimeUnit unit) {		String key = (String) billIdentify.uniqueIdentify();		Jedis jedis = null;		try {			jedis = getResource();			long nano = System.nanoTime();			do {				LOGGER.debug("try lock key: " + key);				Long i = jedis.setnx(key, key);				if (i == 1) { 					jedis.expire(key, DEFAULT_SINGLE_EXPIRE_TIME);					LOGGER.debug("get lock, key: " + key + " , expire in " + DEFAULT_SINGLE_EXPIRE_TIME + " seconds.");					return Boolean.TRUE;				} else { // 存在锁					if (LOGGER.isDebugEnabled()) {						String desc = jedis.get(key);						LOGGER.debug("key: " + key + " locked by another business：" + desc);					}				}				if (timeout == 0) {					break;				}				Thread.sleep(300);			} while ((System.nanoTime() - nano) < unit.toNanos(timeout));			return Boolean.FALSE;		} catch (JedisConnectionException je) {			LOGGER.error(je.getMessage(), je);			returnBrokenResource(jedis);		} catch (Exception e) {			LOGGER.error(e.getMessage(), e);		} finally {			returnResource(jedis);		}		return Boolean.FALSE;	}	/**	 * 如果锁空闲立即返回   获取失败 一直等待	 * @author http://blog.csdn.net/java2000_wl	 * @param billIdentify	 */	public void lock(IBillIdentify billIdentify) {		String key = (String) billIdentify.uniqueIdentify();		Jedis jedis = null;		try {			jedis = getResource();			do {				LOGGER.debug("lock key: " + key);				Long i = jedis.setnx(key, key);				if (i == 1) { 					jedis.expire(key, DEFAULT_SINGLE_EXPIRE_TIME);					LOGGER.debug("get lock, key: " + key + " , expire in " + DEFAULT_SINGLE_EXPIRE_TIME + " seconds.");					return;				} else {					if (LOGGER.isDebugEnabled()) {						String desc = jedis.get(key);						LOGGER.debug("key: " + key + " locked by another business：" + desc);					}				}				Thread.sleep(300); 			} while (true);		} catch (JedisConnectionException je) {			LOGGER.error(je.getMessage(), je);			returnBrokenResource(jedis);		} catch (Exception e) {			LOGGER.error(e.getMessage(), e);		} finally {			returnResource(jedis);		}	}	/**	 * 释放锁	 * @author http://blog.csdn.net/java2000_wl	 * @param billIdentify	 */	public void unLock(IBillIdentify billIdentify) {		List
     
       list = new ArrayList
      
       ();		list.add(billIdentify);		unLock(list);	}	/**	 * 批量获取锁  如果全部获取   立即返回true, 部分获取失败 返回false	 * @author http://blog.csdn.net/java2000_wl	 * @date 2013-7-22 下午10:27:44	 * @param billIdentifyList	 * @return	 */	public boolean tryLock(List
       
         billIdentifyList) {		return tryLock(billIdentifyList, 0L, null);	}		/**	 * 锁在给定的等待时间内空闲，则获取锁成功 返回true， 否则返回false	 * @author http://blog.csdn.net/java2000_wl	 * @param billIdentifyList	 * @param timeout	 * @param unit	 * @return	 */	public boolean tryLock(List
        
          billIdentifyList, long timeout, TimeUnit unit) {		Jedis jedis = null;		try {			List
         
           needLocking = new CopyOnWriteArrayList
          
           (); List
           
             locked = new CopyOnWriteArrayList
            
             (); jedis = getResource(); long nano = System.nanoTime(); do { // 构建pipeline，批量提交 Pipeline pipeline = jedis.pipelined(); for (IBillIdentify identify : billIdentifyList) { String key = (String) identify.uniqueIdentify(); needLocking.add(key); pipeline.setnx(key, key); } LOGGER.debug("try lock keys: " + needLocking); // 提交redis执行计数 List
              results = pipeline.syncAndReturnAll(); for (int i = 0; i < results.size(); ++i) { Long result = (Long) results.get(i); String key = needLocking.get(i); if (result == 1) { // setnx成功，获得锁 jedis.expire(key, DEFAULT_BATCH_EXPIRE_TIME); locked.add(key); } } needLocking.removeAll(locked); // 已锁定资源去除 if (CollectionUtils.isEmpty(needLocking)) { return true; } else { // 部分资源未能锁住 LOGGER.debug("keys: " + needLocking + " locked by another business："); } if (timeout == 0) { break; } Thread.sleep(500); } while ((System.nanoTime() - nano) < unit.toNanos(timeout)); // 得不到锁，释放锁定的部分对象，并返回失败 if (!CollectionUtils.isEmpty(locked)) { jedis.del(locked.toArray(new String[0])); } return false; } catch (JedisConnectionException je) { LOGGER.error(je.getMessage(), je); returnBrokenResource(jedis); } catch (Exception e) { LOGGER.error(e.getMessage(), e); } finally { returnResource(jedis); } return true; } /** * 批量释放锁 * @author http://blog.csdn.net/java2000_wl * @param billIdentifyList */ public void unLock(List
              
                billIdentifyList) { List
               
                 keys = new CopyOnWriteArrayList
                
                 (); for (IBillIdentify identify : billIdentifyList) { String key = (String) identify.uniqueIdentify(); keys.add(key); } Jedis jedis = null; try { jedis = getResource(); jedis.del(keys.toArray(new String[0])); LOGGER.debug("release lock, keys :" + keys); } catch (JedisConnectionException je) { LOGGER.error(je.getMessage(), je); returnBrokenResource(jedis); } catch (Exception e) { LOGGER.error(e.getMessage(), e); } finally { returnResource(jedis); } } /** * @author http://blog.csdn.net/java2000_wl * @date 2013-7-22 下午9:33:45 * @return */ private Jedis getResource() { return jedisPool.getResource(); } /** * 销毁连接 * @author http://blog.csdn.net/java2000_wl * @param jedis */ private void returnBrokenResource(Jedis jedis) { if (jedis == null) { return; } try { //容错 jedisPool.returnBrokenResource(jedis); } catch (Exception e) { LOGGER.error(e.getMessage(), e); } } /** * @author http://blog.csdn.net/java2000_wl * @param jedis */ private void returnResource(Jedis jedis) { if (jedis == null) { return; } try { jedisPool.returnResource(jedis); } catch (Exception e) { LOGGER.error(e.getMessage(), e); } }

 

转载于:https://www.cnblogs.com/ainima/p/6331712.html

你可能感兴趣的文章
SQL 事物
查看>>
双端队列
查看>>
【LOJ】 #2013. 「SCOI2016」幸运数字
查看>>
折腾mysql的小坑记录
查看>>
树莓派入门
查看>>
tyvj1004 滑雪
查看>>
URAL 1143 Electric Path（带方向的区间DP + 记忆化搜索）
查看>>
HDOJ 3033 I love sneakers!（分组背包变型）
查看>>
Oracle系列(一)： Oracle数据恢复
查看>>
js刷新页面的几种方法
查看>>
图像处理---图像分割技术---基于图像灰度分布的阈值方法一
查看>>
关于IE 浏览器的position居中定位的问题和 行块元素的设置问题
查看>>
最长串那点事儿（lis，lcs，lcis）
查看>>
JS实现DropDownList的通用查询
查看>>
css
查看>>
jquery delegate
查看>>
XMPP协议、IM、客户端互联详解
查看>>
多线程GCD
查看>>
Linux下xargs命令详解
查看>>
js获取链接等号“=”后面的参数
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2024-11-08 09:29:22   当前IP: 18.191.186.139   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我