Zookeeper实现分布式锁

最新推荐文章于 2024-04-27 11:03:47 发布

AAA821

最新推荐文章于 2024-04-27 11:03:47 发布

阅读量174

点赞数

分类专栏：分布式

分布式专栏收录该内容

11 篇文章 0 订阅

订阅专栏

分布式锁的要求是什么:

确保锁的实现同时满足以下四个条件：

互斥性。在任意时刻，只有一个客户端能持有锁。
不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。
具有容错性。只要大部分的Redis节点正常运行，客户端就可以加锁和解锁。
解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。

这是Redis实现分布式锁的博文 https://mp.csdn.net/postedit/80117365

以下文章大部分出自

https://blog.csdn.net/qiangcuo6087/article/details/79067136

如何使用zookeeper实现分布式锁？

在描述算法流程之前，先看下zookeeper中几个关于节点的有趣的性质：

有序节点：假如当前有一个父节点为/lock，我们可以在这个父节点下面创建子节点；zookeeper提供了一个可选的有序特性，例如我们可以创建子节点“/lock/node-”并且指明有序，那么zookeeper在生成子节点时会根据当前的子节点数量自动添加整数序号，也就是说如果是第一个创建的子节点，那么生成的子节点为/lock/node-0000000000，下一个节点则为/lock/node-0000000001，依次类推。(多线程下也不会出现两个节点都是lock/node-00这种情况，防止并发)
临时节点：客户端可以建立一个临时节点，在会话结束或者会话超时后，zookeeper会自动删除该节点(保证不会死锁)
事件监听：在读取数据时，我们可以同时对节点设置事件监听，当节点数据或结构变化时，zookeeper会通知客户端。当前zookeeper有如下四种事件：1）节点创建；2）节点删除；3）节点数据修改；4）子节点变更。(为实现解锁创建条件)

下面描述使用zookeeper实现分布式锁的算法流程，假设锁空间的根节点为/lock：

客户端连接zookeeper，并在/lock下创建临时的且有序的子节点，第一个客户端对应的子节点为/lock/lock-0000000000，第二个为/lock/lock-0000000001，以此类推。
客户端获取/lock下的子节点列表，判断自己创建的子节点是否为当前子节点列表中序号最小的子节点，如果是则认为获得锁，否则监听/lock的子节点变更消息，获得子节点变更通知后重复此步骤直至获得锁；
执行业务代码；
完成业务流程后，删除对应的子节点释放锁。

步骤1中创建的临时节点能够保证在故障的情况下锁也能被释放，考虑这么个场景：假如客户端a当前创建的子节点为序号最小的节点，获得锁之后客户端所在机器宕机了，客户端没有主动删除子节点；如果创建的是永久的节点，那么这个锁永远不会释放，导致死锁；由于创建的是临时节点，客户端宕机后，过了一定时间zookeeper没有收到客户端的心跳包判断会话失效，将临时节点删除从而释放锁。

在步骤2中获取子节点列表与设置监听这两步操作的原子性问题，考虑这么个场景：客户端a对应子节点为/lock/lock-0000000000，客户端b对应子节点为/lock/lock-0000000001，客户端b获取子节点列表时发现自己不是序号最小的，但是在设置监听器前客户端a完成业务流程删除了子节点/lock/lock-0000000000，客户端b设置的监听器岂不是丢失了这个事件从而导致永远等待了？这个问题不存在的。因为zookeeper提供的API中设置监听器的操作与读操作是原子执行的，也就是说在读子节点列表时同时设置监听器，保证不会丢失事件。

最后，对于这个算法有个极大的优化点：假如当前有1000个节点在等待锁，如果获得锁的客户端释放锁时，这1000个客户端都会被唤醒，这种情况称为“羊群效应”；在这种羊群效应中，zookeeper需要通知1000个客户端，这会阻塞其他的操作，最好的情况应该只唤醒新的最小节点对应的客户端。应该怎么做呢？在设置事件监听时，每个客户端应该对刚好在它之前的子节点设置事件监听，例如子节点列表为/lock/lock-0000000000、/lock/lock-0000000001、/lock/lock-0000000002，序号为1的客户端监听序号为0的子节点删除消息，序号为2的监听序号为1的子节点删除消息。

有两个例子，先贴网上一个自己实现分布式锁的，虽然有点Bug,但是可以帮助理解思路

package distribute;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

/**
 * 分布式锁
 * 他这个例子的思路就是每个线程都在根节点下创建一个节点,然后每个线程都会获取根节点下所有子节点,然后看自己是不是最小的,是最小的就说明获取到锁
 * 如果不是最小的,就监听，在自己前面的一个节点，利用CountDownLatch(1)来实现阻塞，当监听到前面一个节点被删（因为节点释放锁时节点就会被删掉），就调用countDownLatch.countDown(),这样原本阻塞的，就不会再阻塞，可以获取到锁
 */
public class DistributedLock implements Lock, Watcher {

	private ZooKeeper zk = null;
	// 根节点
	private String ROOT_LOCK = "/locks";
	// 竞争的资源
	private String lockName;
	// 等待的前一个锁
	private String WAIT_LOCK;
	// 当前锁
	private String CURRENT_LOCK;
	// 计数器
	private CountDownLatch countDownLatch;

	private int sessionTimeout = 30000;

	private List<Exception> exceptionList = new ArrayList<Exception>();

	public DistributedLock(String config, String lockName) {
		this.lockName = lockName;
		try {
			// 连接zookeeper
			zk = new ZooKeeper(config, sessionTimeout, this);
			Stat stat = zk.exists(ROOT_LOCK, false);
			if (stat == null) {
				// PERSISTENT 持久性
				zk.create(ROOT_LOCK, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (KeeperException e) {
			e.printStackTrace();
		}
	}


	public void process(WatchedEvent event) {
		System.out.println(Thread.currentThread().getName() + " 监听到");
		if (this.countDownLatch != null) {
			System.out.println(Thread.currentThread().getName() + " 监听到 不为空");
			this.countDownLatch.countDown();
		}
	}

	public void lock() {
		if (exceptionList.size() > 0) {
			throw new RuntimeException(exceptionList.get(0));
		}
		try {
			if (this.tryLock()) {
				System.out.println(Thread.currentThread().getName() + " " + lockName + "获得了锁");
				return;
			} else {
				// 等待锁
				waitForLock(WAIT_LOCK, sessionTimeout);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (KeeperException e) {
			e.printStackTrace();
		}
	}

	public void lockInterruptibly() throws InterruptedException {
		this.lock();
	}

	public boolean tryLock() {
		try {
			String splitStr = "_lock_";
			if (lockName.contains(splitStr)) {
				throw new RuntimeException("锁名有误");
			}
			
			CURRENT_LOCK = zk.create(ROOT_LOCK + "/" + lockName + splitStr, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE,
					CreateMode.EPHEMERAL_SEQUENTIAL);
			System.out.println(CURRENT_LOCK + "已经创建");
			// 取所有子节点
			List<String> subNodes = zk.getChildren(ROOT_LOCK, false);
			// 取出所有lockName的锁
			List<String> lockObjects = new ArrayList<String>();
			for (String node : subNodes) {
				String _node = node.split(splitStr)[0];
				/*
				 * 判断是不是都是test1这个锁的,多个线程会创建test_lock_0,est_lock_1等节点
				 * 因为其它功能也在使用zookeeper,所以还存在其它锁如test2_lock_0,test2_lock_1等节点
				 */
				if (_node.equals(lockName)) {
					lockObjects.add(node);
				}
			}
			Collections.sort(lockObjects);
			System.out.println(Thread.currentThread().getName() + " 的锁是 " + CURRENT_LOCK);
			// 若当前节点是最小节点,则获取锁成功
			if (CURRENT_LOCK.equals(ROOT_LOCK + "/" + lockObjects.get(0))) {
				return true;
			}
			
			String prevNode = CURRENT_LOCK.substring(CURRENT_LOCK.lastIndexOf("/") + 1);
			System.out.println(" tryLock prevNode : " + prevNode);
			WAIT_LOCK = lockObjects.get(Collections.binarySearch(lockObjects, prevNode) - 1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (KeeperException e) {
			e.printStackTrace();
		}
		return false;
	}

	public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
		try {
			if (this.tryLock()) {
				return true;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return false;
	}

	private boolean waitForLock(String prev, long waitTime) throws KeeperException, InterruptedException {
		Stat stat = zk.exists(ROOT_LOCK + "/" + prev, true);
		// 释放锁时,会把节点删掉,所以只要判断它为不为空
		if (stat != null) {
			System.out.println(Thread.currentThread().getName() + " 等待锁 " + ROOT_LOCK + "/" + prev);
			this.countDownLatch = new CountDownLatch(1);
  //调用awit方法时，就会阻塞在这里，然后等上面的process方法调用时
 //（process方法里会执行this.countDownLatch.dountDown,这样就结束阻塞了 
			this.countDownLatch.await(waitTime, TimeUnit.MICROSECONDS);
			this.countDownLatch = null;
			System.out.println(Thread.currentThread().getName() + " 等到了锁 ");
		}
		return true;
	}

	public void unlock() {
		try {
			System.out.println("释放锁 " + CURRENT_LOCK);
			zk.delete(CURRENT_LOCK, -1);
			CURRENT_LOCK = null;
			zk.close();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (KeeperException e) {
			e.printStackTrace();
		}
	}

	public Condition newCondition() {
		return null;
	}

}

先引进Jar包
    <dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-recipes</artifactId>
			<version>4.0.0</version>
	</dependency>
import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;

public class CuratorTest {
	public static void main(String[] args) throws Exception {

		for (int i = 0; i < 10; i++) {
			Thread thread = new Thread(new Runnable() {
				public void run() {
					// 重试策略，在重试之间增加休眠时间，重试设定次数
					RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
					// 创建zookeeper的客户端
					CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181", retryPolicy);

					client.start();

					// 创建分布式锁, 锁空间的根节点路径为/curator/lock
					InterProcessMutex mutex = new InterProcessMutex(client, "/curator/lock");

					System.out.println(Thread.currentThread().getName() + " try Enter mutex");

					try {
						mutex.acquire();

						// 获得了锁, 进行业务流程

						System.out.println(Thread.currentThread().getName() + " Enter mutex");

						// 完成业务流程, 释放锁

						mutex.release();
						System.out.println(Thread.currentThread().getName() + " exit mutex");
					} catch (Exception e) {
						e.printStackTrace();
					}
					// 关闭客户端

					client.close();
				}
			});
			thread.start();
		}
	}
}

AAA821

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Zookeeper实现分布式锁

分布式锁的要求是什么:确保锁的实现同时满足以下四个条件：互斥性。在任意时刻，只有一个客户端能持有锁。不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。具有容错性。只要大部分的Redis节点正常运行，客户端就可以加锁和解锁。解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。这是Redis实现分布式锁的博文...
复制链接

扫一扫