ZK分布式锁实现

1、锁的实现方式

1.1、解决资源竞争问题 性能最低，尽量少用

临界区：通过对多线程的串行化来访问公共资源或一段代码

Synchronized   修身的Java方法，其实就是 Synchronized对 this或类(静态类) 的锁定

1.2、互斥量：采用互斥对象机制。只有拥有互斥对象的线程才能够访问公共资源的权限

Synchronized 修身的代码代码块  ，单台服务器可使用。

2、分布式锁的实现技术

2.1、基于数据库实现分布式锁  多采用乐观锁实现。尽量少用

性能较差，容易出现单点故障

锁没有失效的时间，容易死锁

非阻塞式的

2.2、基于缓存实现分布式锁   小系统多用 。Redis实现原理：保存Redis数据key表示添加了锁，删除key表示解锁。

锁没有失效时间，容易死锁

非阻塞式的

2.3、基于Zookeeper实现分布式锁

实现比较简单、可靠性高、性能较好

3、ZK实现分布式锁

3.1、ZK分布式锁依赖包

      org.slf4j
      slf4j-api
      1.7.10
    
    
      ch.qos.logback
      logback-classic
      1.1.2
    
    
      ch.qos.logback
      logback-core
      1.1.2
    
    
      com.101tec
      zkclient
      0.10
    

3.2、业务需要分布式锁的订单类

import java.text.SimpleDateFormat;
import java.util.Date;
public class OrderFactory {
	private static Integer i=0;
	public  static String GetOrder(){
		//JDK 锁
//		synchronized (i) {
//			i++;
//			return "NewOrder"+new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss-"+i).format(new Date());
//		}
		//分布式锁
		i++;
		String ss= "NewOrder"+new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss-"+i).format(new Date());
		return ss;
	}
}

3.3、分布式锁的接口定义

public interface ILock {
	public void Lock();
	public void UnLock();
}

3.4、分布式锁的抽象类定义

import org.I0Itec.zkclient.ZkClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public  abstract class ZKAbstractLock implements ILock {
	private static Logger log=LoggerFactory.getLogger(ZKAbstractLock.class);
	private static String host="localhost";
	private static String port="2181";
	//分布式锁，通过创建统一的临时节点 创建成功则表示获取锁成功，否则失败
	protected static String node="/zklock";
	protected ZkClient client=new ZkClient(host+":"+port);
	/**
	 * 1：先试着创建临时节点，创建成功则获取锁
	 * 2:如果创建失败，表示已被其他线程上锁了；需要监视这个节点删除(其他线程释放锁)，并且使用CountDownLatch 休眠当前线程
	 * 3:当其他线程释放锁后，唤醒当前线程，重新获取锁。
	 * 缺点：有多个线程等待这个锁时，一个线程释放锁后，其他线程都会被唤醒进行锁的获取(只有一个会成功获取)，
	 * 这样导致竞争激烈，资源浪费。解决思路，当有锁后只有一个线程监视这个节点，其他线程不监视。这个线程释放锁后通知下一个线程获取锁
	 */
	public void Lock() {
		if(tryLock()){
			log.info(Thread.currentThread().getName()+ " Get Lock Success!!!");
		}else{
			//等待之后重新获取锁
			waitforLock();
			Lock();
		}
	}
	public void UnLock() {
		//由于创建的是临时节点，则关闭zk的连接，锁自动释放
		client.close();
	}
	//试着去获取锁
	protected abstract boolean tryLock();
	//等待获取锁
	protected abstract void waitforLock();
}

3.5、分布式锁的实现类

import java.util.concurrent.CountDownLatch;
import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.exception.ZkException;
public class ZKLockImp extends ZKAbstractLock {
	private CountDownLatch cld = null;
	/**
	 * 创建临时节点，创建成功则说明获取锁，否则表示获取锁失败
	 */
	@Override
	protected boolean tryLock() {
		try {
            client.createEphemeral(node);
            return true;
        }
        catch (ZkException e) {
            return false;
        }
	}
	/**
	 * 获取锁失败后，需要在这里让线程休眠等待
	 */
	@Override
	protected void waitforLock() {
		//对ZK创建一个节点监视器 watcher
		IZkDataListener listener = new IZkDataListener() {
			//当zk临时节点删除后触发。当其他线程释放锁后，这个临时节点会被删除，从而触发
			//让CountDownLatch 减一，从而唤醒线程
            public void handleDataDeleted(String dataPath) throws Exception {
                if (cld != null) {
                    cld.countDown();
                }
            }
            //当节点值改变后触发
            public void handleDataChange(String dataPath, Object data)
                    throws Exception {
            }
        };
        //对节点添加监视器
        client.subscribeDataChanges(node, listener);
        //节点存在表示之前有锁已经被占用，让线程等待这里
        if (client.exists(node)) {
            cld = new CountDownLatch(1);
            try {
                cld.await();//(异步等待，指定减为0)线程会在这里堵塞，指定门闩数为0
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //对节点移除监视器
        client.unsubscribeDataChanges(node, listener);
	}
}

3.6、分布式锁获取唯一订单号测试案例

import java.util.concurrent.CountDownLatch;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.hongying.mutithread.OrderFactory;
public class OrderServiceTest implements Runnable  {
private static Logger logger = LoggerFactory.getLogger(OrderServiceTest.class);
    private static int count = 1000;//并发线程数量
    private static CountDownLatch cdl = new CountDownLatch(count);
    ILock lock = new ZKLockImp();
    public void run() {
    	//创建订单
        createOrderNum();
    }
    
    public void createOrderNum() {
        lock.Lock();
        String orderNum = OrderFactory.GetOrder();
        logger.info(Thread.currentThread().getName() + "创建了订单号：【" + orderNum
                + "】！");
        lock.UnLock();
    }
    
    public static void main(String[] args) {
        for (int i = 0; i < count; i++) {
            new Thread(new OrderServiceTest()).start();
            //发令枪里面的数字减一
            cdl.countDown();
        }
    }
}

4、总结

缺点：有多个线程等待这个锁时，一个线程释放锁后，其他线程都会被唤醒进行锁的获取(只有一个会成功获取)，

这样导致竞争激烈，资源浪费。解决思路，采用ZK的临时顺序节点实现，当有锁后只有一个线程监视这个节点，其他线程不监视。这个线程释放锁后通知下一个线程获取锁。

写的一般般，如有更好的解决方案，谢谢分享。后续会再次优化，更新中。。。