Zookeeper、Redis分布式锁，实现与区别

作者：许瑜钊

1、Redis分布式锁实现

a、原理

      Redis为单进程单线程模式，采用队列模式将并发访问变成串行访问，且多客户端对Redis的连接并不存在竞争关系。其次Redis提供一些命令SETNX，GETSET，可以方便实现分布式锁机制。

public  class  RedisKeyLock {

     private  static  Logger logger = Logger.getLogger(RedisKeyLock. class );

     private  final  static  long  ACCQUIRE_LOCK_TIMEOUT_IN_MS =  10  *  1000 ;

     private  final  static  int  EXPIRE_IN_SECOND =  5 ; //锁失效时间

     private  final  static  long  WAIT_INTERVAL_IN_MS =  100 ;

     private  static  RedisKeyLock lock;

     private  JedisPool jedisPool;

     private  RedisKeyLock(JedisPool pool){

         this .jedisPool = pool;

     }

     public  static  RedisKeyLock getInstance(JedisPool pool){

         if (lock ==  null ){

             lock =  new  RedisKeyLock(pool);

         }

         return  lock;

     }

 

     public  void  lock( final  String redisKey) {

         Jedis resource =  null ;

         try  {

             long  now = System.currentTimeMillis();

             resource = jedisPool.getResource();

             long  timeoutAt = now + ACCQUIRE_LOCK_TIMEOUT_IN_MS;

             boolean  flag =  false ;

             while  ( true ) {

                 String expireAt = String.valueOf(now + EXPIRE_IN_SECOND *  1000 );

                 long  ret = resource.setnx(redisKey, expireAt);

                 if  (ret ==  1 ) { //已获取锁

                     flag =  true ;

                     break ;

                 }  else  { //未获取锁，重试获取锁

                     String oldExpireAt = resource.get(redisKey);

                     if  (oldExpireAt !=  null  && Long.parseLong(oldExpireAt) < now) {

                         oldExpireAt = resource.getSet(redisKey, expireAt);

                         if  (Long.parseLong(oldExpireAt) < now) {

                             flag =  true ;

                             break ;

                         }

                     }

                 }

                 if  (timeoutAt < now) {

                     break ;

                 }

               TimeUnit.NANOSECONDS.sleep(WAIT_INTERVAL_IN_MS);

             }

             if  (!flag) {

                 throw  new  RuntimeException( "canot acquire lock now ..." );

             }

         }  catch  (JedisException je) {

             logger.error( "lock" , je);

             je.printStackTrace();

             if  (resource !=  null ) {

                 jedisPool.returnBrokenResource(resource);

             }

         }  catch  (Exception e) {

             e.printStackTrace();

             logger.error( "lock" , e);

         }  finally  {

             if  (resource !=  null ) {

                 jedisPool.returnResource(resource);

             }

         }

     }

     public  boolean  unlock( final  String redisKey) {

         Jedis resource =  null ;

         try  {

             resource = jedisPool.getResource();

             resource.del(redisKey);

             return  true ;

         }  catch  (JedisException je) {

             je.printStackTrace();

             if  (resource !=  null ) {

                 jedisPool.returnBrokenResource(resource);

             }

             return  false ;

         }  catch  (Exception e) {

             logger.error( "lock" , e);

             return  false ;

         }  finally  {

             if  (resource !=  null ) {

                 jedisPool.returnResource(resource);

             }

         }

     }

}

c、代码分析

      lock:通过间隔时间段去请求Redis，来实现阻塞占用，一直到获取锁，或者超时。

     unlock:删除redis中key。

2、Zookeeper分布式锁实现

a、原理

     ZooKeeper核心是一个精简的文件系统，它提供了一些简单的文件操作以及附加的功能 ，它的数据结构原型是一棵znode树（类似Linux的文件系统），并且它们是一些已经被构建好的块，可以用来构建大型的协作数据结构和协议 。

  每个锁都需要一个路径来指定(如:/geffzhang/lock)

1.根据指定的路径, 查找zookeeper集群下的这个节点是否存在.(说明已经有锁了)

2. 如果存在, 根据查询者的一些特征数据(如ip地址/hostname), 当前的锁是不是查询者的

3. 如果不是查询者的锁, 则返回null, 说明创建锁失败

4. 如果是查询者的锁, 则把这个锁返回给查询者

5. 如果这个节点不存在, 说明当前没有锁, 那么创建一个临时节点, 并将查询者的特征信息写入这个节点的数据中, 然后返回这个锁.

据以上5部, 一个分布式的锁就可以创建了.

创建的锁有三种状态:

1. 创建失败(null), 说明该锁被其他查询者使用了.’

2. 创建成功, 但当前没有锁住(unlocked), 可以使用

3. 创建成功, 但当前已经锁住(locked)了, 不能继续加锁.

b、代码样例

public  class  ZooKeeperLock  implements  Lock, Watcher {

 

     private  Logger logger = LoggerFactory.getLogger(getClass());

 

     private  static  final  String SPLITSTR =  "_lock_" ;

     private  static  final  int  SESSION_TIMEOUT =  60000 ; //等锁的毫秒数

     private  static  final  byte [] data =  new  byte [ 0 ];

 

 

     private  ZooKeeper zk =  null ;

 

     private  String root =  "/locks" ; //根

     private  String lockName; //竞争资源的标志

     private  String waitNode; //等待前一个锁

     private  String myZnode; //当前锁

 

     private  CountDownLatch latch; //计数器

 

     /**

      * 创建分布式锁,使用前请确认config配置的zookeeper服务可用

      * @param server 127.0.0.1:2181

      * @param lockName 竞争资源标志,lockName中不能包含单词lock

      */

     public  ZooKeeperLock(String server, String lockName){

         this .lockName = lockName;

         // 创建一个与服务器的连接

         try  {

             zk = initZk(server);

             Stat stat = zk.exists(root,  false );

             if (stat ==  null ){

                 // 创建根节点

                 zk.create(root, data, ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);

             }

         }  catch  (Exception e) {

             throw  new  LockException(e);

         }

     }

 

     /**

      * zookeeper节点的监视器

      */

     @Override

     public  void  process(WatchedEvent event) {

         if ( this .latch !=  null ) {

             this .latch.countDown();

         }

     }

 

     @Override

     public  void  lock() {

         try  {

             if (!tryLock()){

                 boolean  locked = waitForLock(waitNode, SESSION_TIMEOUT, TimeUnit.MILLISECONDS); //等待锁

                 if (!locked){

                     logger.error( "can not lock..." );

                 }

             }

         }  catch  (Exception e) {

             throw  new  LockException(e);

         }

     }

 

     public  boolean  tryLock() {

         try  {

             if (lockName.contains(SPLITSTR)){

                 throw  new  LockException( "lockName can not contains \\u000B" );

             }

             //创建临时子节点

             myZnode = zk.create(root +  "/"  + lockName + SPLITSTR, data, ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);

 

             //取出所有子节点

             List<String> subNodes = zk.getChildren(root,  false );

             //取出所有lockName的锁

             List<String> lockObjNodes =  new  ArrayList<>();

             for  (String node : subNodes) {

                 String _node = node.split(SPLITSTR)[ 0 ];

                 if (_node.equals(lockName)){

                     lockObjNodes.add(node);

                 }

             }

             Collections.sort(lockObjNodes);

 

             if (myZnode.equals(root+ "/" +lockObjNodes.get( 0 ))){

                 //如果是最小的节点,则表示取得锁

                 return  true ;

             }

             //如果不是最小的节点，找到比自己小1的节点

             String subMyZnode = myZnode.substring(myZnode.lastIndexOf( "/" ) +  1 );

             waitNode = lockObjNodes.get(Collections.binarySearch(lockObjNodes, subMyZnode) -  1 );

         }  catch  (Exception e) {

             throw  new  LockException(e);

         }

         return  false ;

     }

 

     @Override

     public  boolean  tryLock( long  time, TimeUnit unit) {

         try  {

             return  tryLock() || waitForLock(waitNode, time, unit);

         }  catch  (Exception e) {

             throw  new  LockException(e);

         }

     }

 

     private  boolean  waitForLock(String lower,  long  waitTime, TimeUnit unit)  throws  InterruptedException, KeeperException {

         Stat stat = zk.exists(root +  "/"  + lower,  true );

         //判断比自己小一个数的节点是否存在,如果不存在则无需等待锁,同时注册监听

         if (stat !=  null ){

             this .latch =  new  CountDownLatch( 1 );

             this .latch.await(waitTime, unit);

             this .latch =  null ;

         }

         return  true ;

     }

 

     @Override

     public  void  unlock() {

         try  {

             zk.delete(myZnode,- 1 );

             myZnode =  null ;

         }  catch  (Exception e) {

             throw  new  LockException(e);

         }

     }

 

     private  synchronized  ZooKeeper initZk(String server) {

         try  {

             if (zk ==  null ){

                 zk =  new  ZooKeeper(server, SESSION_TIMEOUT,  this );

             }

         }  catch  (IOException e) {

             throw  new  LockException( "zk init connect fail"  + e.getMessage());

         }

         return  zk;

     }

 

     @Override

     public  void  lockInterruptibly()  throws  InterruptedException {

         this .lock();

     }

 

     @Override

     public  Condition newCondition() {

         return  null ;

     }

 

     private  class  LockException  extends  RuntimeException {

         private  static  final  long  serialVersionUID = 1L;

         private  LockException(String e){

             super (e);

         }

         private  LockException(Exception e){

             super (e);

         }

     }

}

c、代码分析

      lock:根据根创建锁节点，然后获取当前已经存在锁的节点，如果第一个节点为自己创建，说明没有锁，不是自己加锁，则给自己创建节点的上一个节点加监听，线程阻塞至上一个节点释放，并通知我，或者等待超时。

      unlock:删除自己创建的节点，zookeeper会自动通知加在节点上的监听。

3、两者区别

       Redis分布式锁，必须使用者自己间隔时间轮询去尝试加锁，当锁被释放后，存在多线程去争抢锁，并且可能每次间隔时间去尝试锁的时候，都不成功，对性能浪费很大。

       Zookeeper分布锁，首先创建加锁标志文件，如果需要等待其他锁，则添加监听后等待通知或者超时，当有锁释放，无须争抢，按照节点顺序，依次通知使用者。