`
IXHONG
  • 浏览: 450195 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

分布式锁的三种实现方式

阅读更多

分布式锁大有用途,比如用在减库存操作、流水号生成,分布式计数器等。分布式锁服务在大家的项目中或许用的不多,因为大家都把排他放在数据库那一层来挡。当大量的行锁、表锁、事务充斥着数据库的时候。一般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 <b>1.0.0</b>
 */
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<IBillIdentify> list = new ArrayList<IBillIdentify>();
		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<IBillIdentify> 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<IBillIdentify> billIdentifyList, long timeout, TimeUnit unit) {
		Jedis jedis = null;
		try {
			List<String> needLocking = new CopyOnWriteArrayList<String>();	
			List<String> locked = new CopyOnWriteArrayList<String>();	
			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<Object> 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<IBillIdentify> billIdentifyList) {
		List<String> keys = new CopyOnWriteArrayList<String>();
		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);
		}
	}

 

0
2
分享到:
评论

相关推荐

    分布式锁三种实现方式及对比

    本文将详细讨论三种常见的分布式锁实现方式:基于数据库、基于缓存(如Redis)以及基于Zookeeper,并对比它们的优缺点。 1. **基于数据库实现分布式锁** - **悲观锁**:使用`SELECT ... WHERE ... FOR UPDATE`...

    基于Redis方式实现分布式锁

    分布式锁通常有三种实现方式:基于关系数据库的乐观锁、基于Redis的分布式锁以及基于ZooKeeper的分布式锁。 #### 1. 关系数据库乐观锁 基于关系数据库实现分布式锁主要利用数据库本身的事务机制和锁定机制。在高...

    Java基于redis实现分布式锁代码实例

    Java基于Redis实现分布式锁代码实例 分布式锁的必要性 在多线程环境中,资源竞争是一个常见的问题。例如,在一个简单的用户操作中,一个线程修改用户状态,首先在内存中读取用户状态,然后在内存中进行修改,然后...

    分布式锁的三种实现方式.zip

    数据库锁是一种常见的分布式锁实现方式,通常使用乐观锁或悲观锁机制。在SpringBoot中,可以通过JDBC或MyBatis等持久层框架来操作数据库实现锁。乐观锁通过版本号或时间戳检查来防止并发冲突,而悲观锁则是在读取...

    redis实现分布式锁,自旋式加锁,lua原子性解锁

    自旋式加锁是一种常见的分布式锁实现方式。在Java中,我们可以创建一个`LockService`类,其中包含一个循环尝试获取锁的方法。当尝试获取锁失败时(即`SETNX`返回`false`),线程会进入循环等待一段时间后再次尝试,...

    C#.net Redis分布式锁源码实现

    在IT行业中,尤其是在大型分布式系统的设计与开发中,分布式锁是一种关键的同步机制。本篇文章将深入探讨如何在C#.NET环境下利用Redis实现分布式锁,以及相关的核心知识点。 首先,让我们理解什么是分布式锁。...

    分布式锁的三种实现方式.pdf

    本文将详细介绍三种常用的分布式锁实现方式:基于数据库、基于缓存(如Redis)、以及基于Zookeeper。 #### 一、基于数据库实现分布式锁 数据库作为传统意义上的数据存储介质,在实现分布式锁方面也有其独特的优势...

    解析分布式锁之redis实现1

    分布式锁是一种在分布式系统中确保多个节点对共享资源进行互斥访问的机制...在实际应用中,要充分理解业务需求,根据场景选择合适的分布式锁实现方式,同时确保异常处理和降级策略,以保证系统的稳定性和数据的一致性。

    基于zookeeper的分布式锁简单实现

    分布式锁是一种在分布式系统中实现同步的技术,它允许多个节点在同一时刻访问共享资源。在大型分布式环境中,由于网络延迟和并发操作,简单的本地锁可能无法有效解决数据一致性问题。这时,Zookeeper,一个高可用的...

    记录redisson实现redis分布式事务锁

    首先,Redis作为一个内存数据库,其高速读写性能使其成为实现分布式锁的理想选择。分布式锁的主要作用是在多节点环境下保证同一时刻只有一个节点可以执行特定操作,避免并发问题。Redisson的分布式锁通过`RLock`接口...

    zk:redis分布式锁.zip

    本压缩包“zk:redis分布式锁.zip”提供了基于Zookeeper(zk)和Redis两种分布式锁实现的示例和相关资料。 首先,我们来看Zookeeper(zk)的分布式锁。Zookeeper是Apache的一个开源项目,提供了一个高可用的、高性能...

    使用ZooKeeper实现分布式锁

    这里,我们将深入探讨如何利用ZooKeeper这一强大的分布式协调服务来实现分布式锁,以解决订单编号的唯一性问题。 ZooKeeper是由Apache Hadoop项目孵化的开源项目,它提供了一个高可用、高性能的分布式协调服务。其...

    分布式锁实现(基于redis-mysql)1

    本文主要探讨了三种常见的分布式锁实现方式,包括基于Redis、MySQL以及Zookeeper的实现方法。 **基于Redis实现分布式锁** Redis是一个内存数据库,其命令执行是单线程的,这使得它非常适合用来实现分布式锁。Redis...

    基于Redis的分布式锁的实现方案.pdf

    分布式锁是控制分布式系统之间同步访问共享资源的一种方式。 在分布式锁的设计中,需要满足高性能、避免死锁等基本要求。其中,高性能是指分布式锁不能成为系统的性能瓶颈;避免死锁是指拿到锁的节点挂掉不能导致...

    基于zookeeper的分布式锁实现demo

    Curator提供了现成的分布式锁实现,如`InterProcessMutex`和`InterProcessSemaphoreMutex`,并且提供了易用的API,使得开发人员可以更简单地使用Zookeeper进行分布式锁的实现。 在上述代码片段中,`LockUtil`类是...

    redisson实现分布式锁

    在本例中,"redisson实现分布式锁"是通过AOP(面向切面编程)注解的方式进行使用的。AOP允许我们在不修改业务代码的情况下,对代码进行横切关注点的处理,如日志记录、事务管理、权限控制等。在分布式锁场景中,我们...

    Java Redis分布式锁的正确实现方式详解

    分布式锁有三种实现方式:数据库乐观锁、基于Redis的分布式锁和基于ZooKeeper的分布式锁。本篇博客将详细介绍第二种方式,基于Redis实现分布式锁。 可靠性是分布式锁的重要特性。为了确保分布式锁的可靠性,至少...

    redis实现分布式锁(java/jedis)

    redis实现分布式锁(java/jedis),其中包含工具方法以及使用demo 本资源是利用java的jedis实现 redis实现分布式锁(java/jedis),其中包含工具方法以及使用demo 本资源是利用java的jedis实现

    通过实例解析Java分布式锁三种实现方法

    分布式锁可以分为三种实现方法:基于数据库实现分布式锁、基于缓存(Redis等)实现分布式锁和基于ZooKeeper实现分布式锁。 一、基于数据库实现分布式锁 基于数据库实现分布式锁是使用数据库的排他锁机制来实现...

Global site tag (gtag.js) - Google Analytics