zookeeper学习(二)

什么是分布式锁？
分布式锁一般用在分布式系统或者多个应用中，用来控制同一任务是否执行或者任务的执行顺序。在项目中，部署了多个tomcat应用，在执行定时任务时就会遇到同一任务可能执行多次的情况，我们可以借助分布式锁，保证在同一时间只有一个tomcat应用执行了定时任务（解释：在多个jvm实现同步）
之前我有个疑问:
负载均衡是针对同一组集群来服务的，对吧？就是说这一组集群中的多台机器做一样的功能

分布式锁是不是就是针对这同一组机器而言的

如果是的话，有必要吗？nginx都已经转发到一个具体的机器上了，其他机器不用动啊

比如生成订单号，肯定是订单服务这一组集群在做这件事，但是我们nginx根据负载均衡策略，每次只会让一台机器做事啊?
**对疑问的解答：**就是一旦访问量大了以后基本上每台机器都在生成订单号

分布式场景下生成订单ID

业务场景
在分布式情况，生成全局订单号ID
产生问题
在分布式(集群)环境下，每台JVM不能实现同步，在分布式场景下使用时间戳生成订单号可能会重复
分布式情况下，怎么解决订单号生成不重复
1.使用分布式锁
2.提前生成好，订单号，存放在redis取。获取订单号，直接从redis中取。

使用Zookeeper实现分布式锁

Zookeeper实现分布式锁原理
使用zookeeper创建临时序列节点来实现分布式锁，适用于顺序执行的程序，大体思路就是创建临时序列节点，找出最小的序列节点，获取分布式锁，程序执行完成之后此序列节点消失，通过watch来监控节点的变化，从剩下的节点的找到最小的序列节点，获取分布式锁，执行相应处理，依次类推……
Maven依赖

		
			com.101tec
			zkclient
			0.10
		
	

创建Lock接口

 public interface Lock {
        //获取到锁的资源
    	public void getLock();
        // 释放锁
    	public void unLock();
    }

创建ZookeeperAbstractLock抽象类

//将重复代码写入子类中..
public abstract class ZookeeperAbstractLock implements Lock {
	// zk连接地址
	private static final String CONNECTSTRING = "127.0.0.1:2181";
	// 创建zk连接
	protected ZkClient zkClient = new ZkClient(CONNECTSTRING);
	protected static final String PATH = "/lock";
	public void getLock() {
		if (tryLock()) {
			System.out.println("##获取lock锁的资源####");
		} else {
			// 等待
			waitLock();
			// 重新获取锁资源
			getLock();
		}
	}
	// 获取锁资源
	abstract boolean tryLock();
	// 等待
	abstract void waitLock();
	public void unLock() {
		if (zkClient != null) {
			zkClient.close();
			System.out.println("释放锁资源...");
		}
	} 
}

ZookeeperDistrbuteLock类

public class ZookeeperDistrbuteLock extends ZookeeperAbstractLock {
	private CountDownLatch countDownLatch = null;
	@Override
	boolean tryLock() {
		try {
			zkClient.createEphemeral(PATH);
			return true;
		} catch (Exception e) {
//			e.printStackTrace();
			return false;
		}
}
	@Override
	void waitLock() {
		IZkDataListener izkDataListener = new IZkDataListener() {
            public void handleDataDeleted(String path) throws Exception {
				// 唤醒被等待的线程
				if (countDownLatch != null) {
					countDownLatch.countDown();
				}
			}
			public void handleDataChange(String path, Object data) throws Exception {
			}
		};
		// 注册事件
		zkClient.subscribeDataChanges(PATH, izkDataListener);
		if (zkClient.exists(PATH)) {
			countDownLatch = new CountDownLatch(1);
			try {
				countDownLatch.await();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		// 删除监听
		zkClient.unsubscribeDataChanges(PATH, izkDataListener);
	}
}

生成订单类

package com.itmayiedu.zookeeper;
import java.text.SimpleDateFormat;
import java.util.Date;
//生成订单类
public class OrderNumGenerator {
  //全局订单id
	public static int count = 0;
	public String getNumber() {
		try {
			Thread.sleep(200);
		} catch (Exception e) {
		}
		SimpleDateFormat simpt = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");
		return simpt.format(new Date()) + "-" + ++count;
	}
}

OrderService（在这个类里面有主方法，来运行）

package com.itmayiedu.zookeeper;
public class OrderService implements Runnable {
	private OrderNumGenerator orderNumGenerator = new OrderNumGenerator();
	// 使用lock锁
	// private java.util.concurrent.locks.Lock lock = new ReentrantLock();
	private Lock lock = new ZookeeperDistrbuteLock();
	public void run() {
		getNumber();
	}
	public void getNumber() {
		try {
			lock.getLock();
			String number = orderNumGenerator.getNumber();
			System.out.println(Thread.currentThread().getName() + ",生成订单ID:" + number);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unLock();
		}
	}
	public static void main(String[] args) {
		System.out.println("####生成唯一订单号###");
//		OrderService orderService = new OrderService();
		for (int i = 0; i < 100; i++) {
			new Thread( new OrderService()).start();
		}
	}
}

解析代码运行流程：
lock是接口，ZookeeperAbstractLock是抽象类，ZookeeperDistrbuteLock是实现类（lock–>ZookeeperAbstractLock–>ZookeeperDistrbuteLock）

然后我们再来看ZookeeperDistrbuteLock里面的(从ZookeeperAbstractLock抽象类继承过来的)getLock方法

里面有tryLock方法，接下来我们再来看tryLock方法

所以上面的getLock方法就会执行 System.out.println("##获取lock锁的资源####");
如果这个时候又来一个线程执行lock.getLock方法（在orderServcie类里面）