第5章：基于zookeeper的分布式锁实现

最新推荐文章于 2024-09-11 00:05:05 发布
最新推荐文章于 2024-09-11 00:05:05 发布
阅读量2w 收藏 2
点赞数 2
分类专栏： 手把手进阶zookeeper 手把手进阶zookeeper 文章标签： zookeeper 分布式 分布式锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flykinghg/article/details/52875465
版权

1、使用场景

分布式锁主要应用在跨主机，跨网络资源访问中的协调控制，例如多个task处理任务，但是要求一个任务只能限制在一台task上处理，这里就可以采取分布式锁来实现访问控制协调。

2、实现逻辑


基本思想：通过创建一个持久化根节点作为本次锁行为根节点，每个需要获取资源的分布式业务注册一个临时顺序节点挂载到根节点下，每个分布式业务通过节点的顺序来获取锁。在通过顺序节点获取锁的时候有两种方式：

方式1：简单轮询，只要没有超时限制，就不断尝试获取锁，直到获取到了就返回。

方式2：通过监听前一个顺序节点的方式，只要前一个顺序节点释放（删除了节点）就再次获取，否则就阻塞等待，这种方式存在并发竞争问题，例如，节点已经释放后，再挂载监听此节点的事件，就会导致事件一直不会触发，不断等待下去。

3、代码实现

接口定义如下 
/**
 * 
 */
package com.flykingmz.zookeeper.dLock;

import java.util.concurrent.TimeUnit;

/**
 * @author flyking
 * 
 */
public interface DistributedLock {
	/**
	 * 获取锁，如果没有得到就一直等待
	 * @throws Exception
	 */
	void lock() throws Exception;

	/**
	 * 获取锁，直到指定时间time超时返回
	 * @param time
	 * @param unit
	 * @return
	 * @throws Exception
	 */
	boolean lock(long time, TimeUnit unit) throws Exception;

	/**
	 * 释放锁
	 * @throws Exception
	 */
	void unLock() throws Exception;
	
	/**
	 * 释放根节点锁
	 * @throws Exception
	 */
	void release() throws Exception;
}
简单实现类 
/**
 * 
 */
package com.flykingmz.zookeeper.dLock;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import org.I0Itec.zkclient.IZkChildListener;
import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;
import org.I0Itec.zkclient.exception.ZkNoNodeException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 实现的一个基于zookeeper的简单分布式锁实现
 * 初始化需要传递zookeeper的host+port
 * @author flyking
 * 
 */
public class SimpleDistributedLock implements DistributedLock {
	private final static Logger logger = LoggerFactory
			.getLogger(SimpleDistributedLock.class);

	private ZkClient client;
	private String rootLockerName;
	private String SUB_LOCK_NAME_PREFIX = "sublock-";
	private ThreadLocal<String> currentLockPath = new ThreadLocal<String>();

	public SimpleDistributedLock(String serverstring, String rootLockerName) {
		this.client = new ZkClient(serverstring);
		this.rootLockerName = rootLockerName;
		this.createRootLock();
	}

	/**
	 * 基于临时序列节点创建的一个锁
	 */
	private void createLock() {
		String selfPath = client.createEphemeralSequential(rootLockerName.concat("/").concat(SUB_LOCK_NAME_PREFIX), 1);
		logger.info("thread {},create Lock and path is {}",Thread.currentThread().getId(),selfPath);
		currentLockPath.set(selfPath.substring(selfPath.lastIndexOf("/")+1));
	}

	/**
	 * 基于持久节点创建的锁的根节点
	 */
	private void createRootLock() {
		this.client.createPersistent(rootLockerName);
	}

	/**
	 * 删除锁
	 */
	private void deleteLock() {
		String selfPath = currentLockPath.get();
		client.delete(rootLockerName.concat("/").concat(
				selfPath));
		logger.info("thread {},delete Lock and path is {} and time {}",Thread.currentThread().getId(),rootLockerName.concat("/").concat(
				selfPath),System.currentTimeMillis());
	}

	/**
	 * 尝试获取锁，如果有返回已获取，如果锁被占用就返回未获取
	 * @return
	 */
	private boolean tryLock() {
		List<String> sortedLocks = this.getSortedChildren();
		String lockPath = currentLockPath.get();
		if (sortedLocks.indexOf(lockPath) == 0) {
			logger.info("thread {} try get Lock ",Thread.currentThread().getId());
			return true;
		}
		return false;
	}

	/**
	 * 获取排序好的子节点
	 * @return
	 */
	private List<String> getSortedChildren() {
		try {
			List<String> children = client.getChildren(rootLockerName);
			Collections.sort(children, new Comparator<String>() {
				public int compare(String lhs, String rhs) {
					return getLockNodeNumber(lhs).compareTo(
							getLockNodeNumber(rhs));
				}
			});
			return children;

		} catch (ZkNoNodeException e) {
			this.createRootLock();
			return getSortedChildren();
		}
	}

	/**
	 * 截取锁编号
	 * @param str zk的临时序列节点名称
	 * @return
	 */
	private String getLockNodeNumber(String str) {
		int index = str.lastIndexOf(SUB_LOCK_NAME_PREFIX);
		if (index >= 0) {
			return index <= str.length() ? str.substring(index) : "";
		}
		return str;
	}

	/**
	 * 阻塞获取锁,存在锁释放和锁监听的并发竞争问题
	 * 需要优化
	 * @param timeToWait
	 * 阻塞最大等待的时间(ms)
	 * @param usePollMode
	 * 是否采用简单轮询模式，还是阻塞等待模式
	 * @return
	 */
	@Deprecated
	private boolean blockLock(long timeToWait, boolean usePollMode) {
		logger.info("thread {} enter block Lock ",Thread.currentThread().getId());
		if(usePollMode){
			return this.blockLock(timeToWait);
		}
		long starTime = System.currentTimeMillis();
		while ((System.currentTimeMillis() - starTime) < timeToWait) {
			boolean getLock = this.tryLock();
			if(getLock){
				logger.info("thread {} block get Lock ",Thread.currentThread().getId());
				return true;
			}
			if (!getLock) {
				List<String> sortedLocks = this.getSortedChildren();
				String lockPath = currentLockPath.get();
				if(sortedLocks.indexOf(lockPath) == 0){
					logger.info("thread {} block get Lock ",Thread.currentThread().getId());
					return true;
				}
				int preIndex = sortedLocks.indexOf(lockPath) - 1;
				String preIndexPath = sortedLocks.get(preIndex);
				String preSequencePath = rootLockerName.concat("/").concat(
						preIndexPath);
				logger.info("thread {} start listen {} and time {} ",Thread.currentThread().getId(),preSequencePath,System.currentTimeMillis());
				final CountDownLatch latch = new CountDownLatch(1);
				IZkDataListener dataListener = new IZkDataListener() {
					
					public void handleDataDeleted(String dataPath) throws Exception {
						logger.info("data path {} handleDataDeleted ",dataPath);									
					}
					
					public void handleDataChange(String dataPath, Object data) throws Exception {
						logger.info("data path {} handleDataChange ",dataPath);						
					}
				};
				
				try {
					client.subscribeDataChanges(preSequencePath,dataListener);
					logger.info("thread {} start wait {} and time {}",Thread.currentThread().getId(),rootLockerName,System.currentTimeMillis());
					latch.await();
				} catch (ZkNoNodeException e){
					logger.info("zk client ZkNoNodeException error!", e);
					client.subscribeDataChanges(preSequencePath, dataListener);
				}catch (Exception e) {
				}

			} else {
				logger.info("thread {} block get Lock ",Thread.currentThread().getId());
				return true;
			}

		}
		return false;
	}
	
	/**
	 * 阻塞等待获取锁，简单的轮询实现
	 * @param timeToWait
	 * 阻塞最大等待的时间(ms)
	 * @return
	 */
	private boolean blockLock(long timeToWait) {
		logger.info("thread {} enter block Lock ",Thread.currentThread().getId());
		long starTime = System.currentTimeMillis();
		while ((System.currentTimeMillis() - starTime) < timeToWait) {
			boolean getLock = this.tryLock();
			if(getLock){
				logger.info("thread {} block get Lock ",Thread.currentThread().getId());
				return true;
			}
		}
		return false;
	}

	public void lock() throws Exception {
		this.createLock();
		boolean isLock = this.tryLock();
		if (isLock) {
			return;
		}
		this.blockLock(Long.MAX_VALUE);
	}

	public boolean lock(long time, TimeUnit unit) throws Exception {
		this.createLock();
		boolean isLock = this.tryLock();
		if (isLock) {
			return true;
		}
		isLock = this.blockLock(unit.toMillis(time));
		if (isLock) {
			return true;
		}
		return false;
	}

	public void unLock() throws Exception {
		this.deleteLock();
	}

	public void release() throws Exception {
		this.client.delete(rootLockerName);
		this.client.close();
	}

}
测试代码类 
package com.flykingmz.zookeeper.dLock;

import java.util.concurrent.CountDownLatch;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TestSimpleDistributedLock {
	private final static Logger logger = LoggerFactory
			.getLogger(TestSimpleDistributedLock.class);
	
	private static final int THREAD_NUM = 100; 
	private static final CountDownLatch threadSemaphore = new CountDownLatch(THREAD_NUM);  

	/**
	 * @param args
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException {
		final DistributedLock dc = new SimpleDistributedLock("host:port","/rootLock");  
		 for(int i=0; i < THREAD_NUM; i++){  
	            new Thread(){  
	                @Override  
	                public void run() {  
	                    try{  
	                        logger.info("thread start no "+Thread.currentThread().getId());
	                        dc.lock();
	                        dc.unLock();
	                        threadSemaphore.countDown();
	                    } catch (Exception e){  
	                        e.printStackTrace();  
	                    }  
	                }  
	            }.start();  
	        }  
	        try {  
	            threadSemaphore.await();  
				dc.release();
	            logger.info("所有线程运行结束!");  
	        } catch (InterruptedException e) {  
	            e.printStackTrace();  
	        } catch (Exception e) {
				e.printStackTrace();
			} 
	}

}

4、结果

10个线程模拟分布式业务获取锁，日志打印如下： 
2016-10-20 18:07:04 [Thread-1] INFO com.flykingmz.zookeeper.dLock.TestSimpleDistributedLock  - thread start no 12
2016-10-20 18:07:04 [Thread-4] INFO com.flykingmz.zookeeper.dLock.TestSimpleDistributedLock  - thread start no 15
2016-10-20 18:07:04 [Thread-5] INFO com.flykingmz.zookeeper.dLock.TestSimpleDistributedLock  - thread start no 16
2016-10-20 18:07:04 [Thread-3] INFO com.flykingmz.zookeeper.dLock.TestSimpleDistributedLock  - thread start no 14
2016-10-20 18:07:04 [Thread-8] INFO com.flykingmz.zookeeper.dLock.TestSimpleDistributedLock  - thread start no 19
2016-10-20 18:07:04 [Thread-2] INFO com.flykingmz.zookeeper.dLock.TestSimpleDistributedLock  - thread start no 13
2016-10-20 18:07:04 [Thread-9] INFO com.flykingmz.zookeeper.dLock.TestSimpleDistributedLock  - thread start no 20
2016-10-20 18:07:04 [Thread-7] INFO com.flykingmz.zookeeper.dLock.TestSimpleDistributedLock  - thread start no 18
2016-10-20 18:07:04 [Thread-6] INFO com.flykingmz.zookeeper.dLock.TestSimpleDistributedLock  - thread start no 17
2016-10-20 18:07:04 [Thread-10] INFO com.flykingmz.zookeeper.dLock.TestSimpleDistributedLock  - thread start no 21
2016-10-20 18:07:04 [Thread-6] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 17,create Lock and path is /rootLock/sublock-0000000000
2016-10-20 18:07:04 [Thread-3] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 14,create Lock and path is /rootLock/sublock-0000000001
2016-10-20 18:07:04 [Thread-1] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 12,create Lock and path is /rootLock/sublock-0000000002
2016-10-20 18:07:04 [Thread-8] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 19,create Lock and path is /rootLock/sublock-0000000003
2016-10-20 18:07:04 [Thread-5] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 16,create Lock and path is /rootLock/sublock-0000000004
2016-10-20 18:07:04 [Thread-2] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 13,create Lock and path is /rootLock/sublock-0000000005
2016-10-20 18:07:04 [Thread-7] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 18,create Lock and path is /rootLock/sublock-0000000006
2016-10-20 18:07:04 [Thread-4] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 15,create Lock and path is /rootLock/sublock-0000000007
2016-10-20 18:07:04 [Thread-9] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 20,create Lock and path is /rootLock/sublock-0000000008
2016-10-20 18:07:04 [Thread-10] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 21,create Lock and path is /rootLock/sublock-0000000009
2016-10-20 18:07:04 [Thread-3] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 14 enter block Lock 
2016-10-20 18:07:04 [Thread-6] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 17 try get Lock 
2016-10-20 18:07:04 [Thread-1] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 12 enter block Lock 
2016-10-20 18:07:04 [Thread-8] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 19 enter block Lock 
2016-10-20 18:07:04 [Thread-5] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 16 enter block Lock 
2016-10-20 18:07:04 [Thread-2] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 13 enter block Lock 
2016-10-20 18:07:04 [Thread-7] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 18 enter block Lock 
2016-10-20 18:07:04 [Thread-4] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 15 enter block Lock 
2016-10-20 18:07:04 [Thread-9] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 20 enter block Lock 
2016-10-20 18:07:04 [Thread-10] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 21 enter block Lock 
2016-10-20 18:07:04 [Thread-6] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 17,delete Lock and path is /rootLock/sublock-0000000000 and time 1476958024362
2016-10-20 18:07:04 [Thread-3] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 14 try get Lock 
2016-10-20 18:07:04 [Thread-3] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 14 block get Lock 
2016-10-20 18:07:04 [Thread-3] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 14,delete Lock and path is /rootLock/sublock-0000000001 and time 1476958024377
2016-10-20 18:07:04 [Thread-1] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 12 try get Lock 
2016-10-20 18:07:04 [Thread-1] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 12 block get Lock 
2016-10-20 18:07:04 [Thread-1] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 12,delete Lock and path is /rootLock/sublock-0000000002 and time 1476958024393
2016-10-20 18:07:04 [Thread-8] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 19 try get Lock 
2016-10-20 18:07:04 [Thread-8] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 19 block get Lock 
2016-10-20 18:07:04 [Thread-8] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 19,delete Lock and path is /rootLock/sublock-0000000003 and time 1476958024408
2016-10-20 18:07:04 [Thread-5] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 16 try get Lock 
2016-10-20 18:07:04 [Thread-5] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 16 block get Lock 
2016-10-20 18:07:04 [Thread-5] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 16,delete Lock and path is /rootLock/sublock-0000000004 and time 1476958024408
2016-10-20 18:07:04 [Thread-2] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 13 try get Lock 
2016-10-20 18:07:04 [Thread-2] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 13 block get Lock 
2016-10-20 18:07:04 [Thread-2] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 13,delete Lock and path is /rootLock/sublock-0000000005 and time 1476958024424
2016-10-20 18:07:04 [Thread-7] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 18 try get Lock 
2016-10-20 18:07:04 [Thread-7] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 18 block get Lock 
2016-10-20 18:07:04 [Thread-7] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 18,delete Lock and path is /rootLock/sublock-0000000006 and time 1476958024440
2016-10-20 18:07:04 [Thread-4] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 15 try get Lock 
2016-10-20 18:07:04 [Thread-4] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 15 block get Lock 
2016-10-20 18:07:04 [Thread-4] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 15,delete Lock and path is /rootLock/sublock-0000000007 and time 1476958024440
2016-10-20 18:07:04 [Thread-9] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 20 try get Lock 
2016-10-20 18:07:04 [Thread-9] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 20 block get Lock 
2016-10-20 18:07:04 [Thread-9] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 20,delete Lock and path is /rootLock/sublock-0000000008 and time 1476958024455
2016-10-20 18:07:04 [Thread-10] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 21 try get Lock 
2016-10-20 18:07:04 [Thread-10] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 21 block get Lock 
2016-10-20 18:07:04 [Thread-10] INFO com.flykingmz.zookeeper.dLock.SimpleDistributedLock  - thread 21,delete Lock and path is /rootLock/sublock-0000000009 and time 1476958024455
2016-10-20 18:07:04 [ZkClient-EventThread-9-172.16.10.58:2181] INFO org.I0Itec.zkclient.ZkEventThread  - Terminate ZkClient event thread.
2016-10-20 18:07:04 [main-EventThread] INFO org.apache.zookeeper.ClientCnxn  - EventThread shut down
2016-10-20 18:07:04 [main] INFO org.apache.zookeeper.ZooKeeper  - Session: 0x25776ad02740082 closed
2016-10-20 18:07:04 [main] INFO com.flykingmz.zookeeper.dLock.TestSimpleDistributedLock  - 所有线程运行结束!

基于zookeeper实现的分布式锁全部源代码可以到github上下载，地址：https://github.com/flykingmz/zookeeper-step.git，具体项目名称为：distributedLock





辉哥的IT杂货铺
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
zookeeper（四）实现分布式锁
qq_26737667的博客
02-20 122
zookeeper实现分布式锁 实现原理 根据zookeeper结点的特点，可以通过创建临时有序节点来创建排他锁。 引入pom <dependency> <groupId>org.apache.zookeeper</groupId> <artifactId>zookeeper</artifactId> ...
Zookeeper(2)-分布式锁的基础实现
wadfdhsajd的博客
06-12 170
在进行分布式锁操作之前，我们得知道什么是分布式锁。在单体应用中，使用 API 自带的 javaLock 或者是 synchronize 就可以解决线程多带来的并发问题。但是在中，上述的方法并不能解决服务与服务之间的并发问题。分布式锁一般用在分布式系统或者多个应用中，用来控制同一任务是否执行或者任务的执行顺序。在项目中，部署了多了应用，在执行定时任务时就会遇到同一任务可能执行多次的情况，我们可以借助分布式锁，保证在同一时间只有一个tomcat应用执行了定时任务使用 Zookeeper 创建临时顺序节点，判断
JUC——深入理解 ThreadLocal 与源码分析 以及 概念掌握 （案例实战——ThreadLocal结合ZooKeeper实现分布式锁 ）
Alascanfu的博客
04-21 1525
📖本文目录📖 ThreadLocal 详解📑 ThreadLocal 简介📑 ThreadLocal 与 Synchronized 区别📑 ThreadLocal 的基本使用📑 ThreadLocal 的原理🔖 ThreadLocal 的 set() 方法🔖 什么是ThreadLocalMap🔖 ThreadLocal 的 get() 方法🔖 ThreadLocal 的 remove()方法📚 内存泄漏问题🔖 Thread 、 ThreadLocalMap 与 ThreadLocal 三者关系📑 Threa
zookeeper实现分布式锁
u014732205的博客
11-13 2458
1.zookeeper简介 2.zookeeper实现分布式锁
实战：ZooKeeper实现分布式锁
为无为，事无事，味无味。
07-29 980
假定，取水时以家庭为单位，家庭的某人拿到号，其他的家庭成员过来打水，这时候不用再取号，如图10-4所示。图10-4 同一家庭的人不需要重复排队图10-4中，排在1号的家庭，老公取号，假设其老婆来了，直接排第一个，正所谓妻凭夫贵。再看上图的2号，父亲正在打水，假设其儿子和女儿也到井边了，直接排第二个，所谓子凭父贵。总之，如果取水时以家庭为单位，则同一个家庭，可以直接复用排号，不用从后面排起重新取号。以上这个故事模型中，取号一次，可以用来多次取水，其原理为可重入锁的模型。
第四十九章：zookeeper分布式协调工具1
08-08
ZooKeeper 是一个由 Apache 开发的分布式协调服务，它是 Google Chubby 的开源实现。ZooKeeper 提供了简单但强大的功能，如分布式同步、配置管理、集群管理和命名服务。它的数据模型基于文件系统目录树，使得开发者...
zookeeper分布式锁
2401_83916030的博客
04-04 952
无论是哪家公司，都很重视高并发高可用的技术，重视基础，重视JVM。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，是不是能真的得到锻炼。其实我写了这么多，只是我自己的总结，并不一定适用于所有人，相信经过一些面试，大家都会有这些感触。最后我整理了一些面试真题资料，技术知识点剖析教程，还有和广大同仁一起交流学习共同进步，还有一些职业经验的分享。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》
基于ZooKeeper的分布式锁实现（C++版本）
warden007的博客
02-09 3619
一、简介分布式同步是Zookeeper的功能之一，但Zookeeper的分布式同步（分布式锁）功能并非以直接的接口呈现的。开发者需要额外地基于Zookeeper的节点（node）的分布式同步特性来实现分布式锁的接口。本文将提供基于基于ZooKeeper的分布式锁的C++接口及实现，实现中用到了部分C++11特性。另外，本实现使用的是经过封装的ZooKeeper接口，本文只列出这些ZooKeeper...
通过zookeeper实现分布式锁
11-13
【Zookeeper实现分布式锁】 Zookeeper 是 Apache ...总之，Zookeeper 的分布式锁机制是基于其强大的一致性特性和事件通知能力实现的，它在分布式系统中扮演着至关重要的角色，帮助协调和管理分布式环境下的并发操作。
使用ZooKeeper原生API实现分布式锁
JHIII的博客
08-12 193
前文分析，实现分布式锁的流程是： 抢锁就是创建临时有序节点，监听创建成功后，获取根节点（连接zk集群时候的根节点）下的所有孩子节点，然后比较当前节点时候为第一个（要排好序），若是第一个，则抢锁成功，做自己的业务，然后释放锁-删除节点，当然删除节点也会触发回调。还有，zk的事件监听机制。zk上所有的节点，持久节点，顺序节点，临时顺序节点等都可以对它进行监听，当某一个节点上发生了变化，比如当节点被创建了、数据更新、能帮我们解决这个问题，我们只监听顺序节点的前一个节点，看它是不是顺序最小的，让顺序最小的获得锁！.
第6章：基于zookeeper的配置管理中心
热门推荐
flykinghg的博客
10-26 2万+
第6章：基于zookeeper的配置管理中心
第1章：zookeeper介绍
flykinghg的博客
09-21 1万+
第1章：zookeeper介绍
第4章: zookeeper 基础API使用
flykinghg的博客
10-09 1万+
第4章：zookeeper 基础API使用
第2章：zookeeper安装
flykinghg的博客
09-21 1万+
第2章：zookeeper安装
第7章：基于zookeeper的分布式session
flykinghg的博客
11-10 2845
基于zookeeper的分布式session
ZooKeeper 中的 Curator 框架解析
qq_56438516的博客
09-08 1130
Curator 是 Netflix 开发的一个开源库，旨在简化 ZooKeeper 的使用。它提供了一套丰富的工具和高级抽象，使得开发者可以更容易地构建分布式协调服务。Curator 通过提供简单易用的 API 和高级抽象，极大地简化了 ZooKeeper 的使用。它不仅提高了开发效率，还增强了代码的健壮性和可测试性。通过本文的介绍，希望你能对 Curator 有一个基本的了解，并能够在实际项目中应用它来构建分布式协调服务。
如何确定kafka与zookeeper版本的对应关系
别来沾边儿
09-09 558
真希望官方可以贴心的整理出所有版本和zookeeper的对应关系，从目前kafka发展的趋势来看，都已经移除zookeeper依赖了，这件事也是木戏，哈哈哈；从解压目录我们可以kafka的源码是基于gradle的，我们只需要去gradle的依赖中找找zookeeper依赖的版本即可；搜索zookeeper关键字，可以看到Kafka2.7.2对应的Zookeeper版本为3.5.9。大家可以额外思考一下，如果用更高版本的zookeeper，kafka运行会不会有问题？这嘎嘎一列版本对应关系，哪来的呢？
Dubbo 与 Zookeeper 在项目中的应用：原理与实现详解
最新发布
lssffy的博客
09-11 1428
Dubbo 是阿里巴巴开源的高性能、轻量级的 RPC 框架，主要用于提供分布式服务架构下的远程服务调用。Dubbo 的设计初衷是为了解决微服务架构下服务之间的远程调用、负载均衡、服务路由等问题。它通过将每个服务都模块化并封装为独立的服务，使得服务间可以通过网络进行调用。Zookeeper 是一个分布式协调服务，旨在解决分布式系统中的数据管理问题。它可以提供配置管理、分布式锁、集群管理、服务发现等功能。Zookeeper 采用树形数据结构存储数据，并通过简单的 API 实现高效的节点监控和管理。
RedLock算法详解：Redis与Zookeeper分布式锁实战
本文档不仅介绍了RedLock算法的设计思想和实现细节，还涵盖了Zookeeper分布式锁的原理和应用案例，适合那些需要处理高并发分布式锁挑战的开发人员参考和学习。理解并掌握这些技术对于构建可扩展、高可用的分布式系统...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值