分布式锁

分布锁满足条件
1、在分布式系统环境下，一个方法在同一时间只能被一个机器的一个线程执行；
2、高可用的获取锁与释放锁；
3、高性能的获取锁与释放锁；
4、具备可重入特性；
5、具备锁失效机制，防止死锁；
6、具备非阻塞锁特性，即没有获取到锁将直接返回获取锁失败。

redis分布式锁和zk分布式锁的对比
redis分布式锁，其实需要自己不断去尝试获取锁，比较消耗性能；
zk分布式锁，获取不到锁，注册个监听器即可，不需要不断主动尝试获取锁，性能开销较小。
另外一点就是，如果是redis获取锁的那个客户端bug了或者挂了，那么只能等待超时时间之后才能释放锁；而zk的话，因为创建的是临时znode，只要客户端挂了，znode就没了，此时就自动释放锁。
redis分布式锁大家每发现好麻烦吗？遍历上锁，计算时间等等。zk的分布式锁语义清晰实现简单。
所以先不分析太多的东西，就说这两点，我个人实践认为zk的分布式锁比redis的分布式锁牢靠、而且模型简单易用。

zk 实现分布式锁

public class ZooKeeperDistributedLock implements Watcher {

  private ZooKeeper zk;
  private String locksRoot= "/mylocks";
  private String productId;
  private String waitNode;
  private CountDownLatch latch;
  private String lockNode;
  private CountDownLatch connectedLatch = new CountDownLatch(1);//线程计数器，用于线程等待
  private int sessionTimeout = 30000;

  public ZooKeeperDistributedLock(String productId){
    this.productId = productId;
    try {
      String address = "10.118.13.45:2181";
      zk = new ZooKeeper(address, sessionTimeout, this);
      connectedLatch.await();
    } catch (IOException e) {
      throw new LockException(e);
    } catch (InterruptedException e) {
      throw new LockException(e);
    }
  }

  public void process(WatchedEvent event) {
    if(event.getState()==KeeperState.SyncConnected){
      connectedLatch.countDown();
      return;
    }
    if(this.latch != null) {
      this.latch.countDown();
    }
  }

  public void acquireDistributedLock() {
    try {
      if(this.tryLock()){
        return;
      }
      else{
        waitForLock(waitNode, sessionTimeout);
      }
    } catch (KeeperException e) {
      throw new LockException(e);
    } catch (InterruptedException e) {
      throw new LockException(e);
    }
  }


  /***
   * 获取锁
   * @return
   */
  public boolean tryLock() {
    try {
      // 传入进去的locksRoot + “/” + productId
      // 假设productId代表了一个商品id，比如说1
      // locksRoot = locks
      // /locks/10000000000，/locks/10000000001，/locks/10000000002
      Stat exists = zk.exists(locksRoot, false);
      if(exists==null){
        lockNode = zk.create(locksRoot, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
      }
      lockNode = zk.create(locksRoot + "/" + productId, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
      // 看看刚创建的节点是不是最小的节点
      // locks：10000000000，10000000001，10000000002
      List<String> locks = zk.getChildren(locksRoot, false);
      Collections.sort(locks);

      if(lockNode.equals(locksRoot+"/"+ locks.get(0))){
        //如果是最小的节点,则表示取得锁
        return true;
      }
      //如果不是最小的节点，找到比自己小1的节点
      int previousLockIndex = -1;
      for(int i = 0; i < locks.size(); i++) {
        if(lockNode.equals(locksRoot + "/" + locks.get(i))) {
          previousLockIndex = i - 1;
          break;
        }
      }

      this.waitNode = locks.get(previousLockIndex);
    } catch (KeeperException e) {
      throw new LockException(e);
    } catch (InterruptedException e) {
      throw new LockException(e);
    }
    return false;
  }


  /***
   * 等待锁
   * @param waitNode
   * @param waitTime
   * @return
   * @throws InterruptedException
   * @throws KeeperException
   */
  private boolean waitForLock(String waitNode, long waitTime) throws InterruptedException, KeeperException {
    Stat stat = zk.exists(locksRoot + "/" + waitNode, true);
    if(stat != null){
      this.latch = new CountDownLatch(1);
      //等待上一个节点释放，释放后执行
      this.latch.await(waitTime, TimeUnit.MILLISECONDS);
      this.latch = null;
    }
    return true;
  }


  /***
   * 释放锁
   */
  public void unlock() {
    try {
      // 删除/locks/10000000000节点
      // 删除/locks/10000000001节点
      System.out.println("unlock " + lockNode);
      zk.delete(lockNode,-1);
      lockNode = null;
      zk.close();
    } catch (InterruptedException e) {
      e.printStackTrace();
    } catch (KeeperException e) {
      e.printStackTrace();
    }
  }

  public class LockException extends RuntimeException {
    private static final long serialVersionUID = 1L;
    public LockException(String e){
      super(e);
    }
    public LockException(Exception e){
      super(e);
    }
  }


  public static void main(String[] args) {
    Thread thread = new Thread();


  }

// 如果有一把锁，被多个人给竞争，此时多个人会排队，第一个拿到锁的人会执行，然后释放锁，后面的每个人都会去监听排在自己前面的那个人创建的node上，一旦某个人释放了锁，排在自己后面的人就会被zookeeper给通知，一旦被通知了之后，就ok了，自己就获取到了锁，就可以执行代码了
}

　　

pom

  <dependency>
      <groupId>com.101tec</groupId>
      <artifactId>zkclient</artifactId>
      <version>0.10</version>
    </dependency>

　　

调用代码

//分布式锁
ZooKeeperDistributedLock zooKeeperDistributedLock = new ZooKeeperDistributedLock("001");
zooKeeperDistributedLock.acquireDistributedLock();
zooKeeperDistributedLock.unlock();