17、Redis、Zk分布式锁实现原理

我们在编程有很多场景使用本地锁和分布式锁，但是是否考虑这些锁的原理是什么？本篇讨论下实现分布式锁的常见办法及他们实现原理。

一、使用锁的原则

使用本地锁和分布式锁是为了解决并发导致脏数据的场景，使用锁的最高境界是通过流程设计避免使用锁，锁会牺牲掉系统性能为代价的。

1、常见的分布式锁实现

常见分布式锁产品性能：redis>zookeeper>mysql，获取锁成功率：mysql悲观>zk>redis

锁实现	实现方式	性能	选型注意	选择关注点
mysql	乐观锁	好	并发场景锁无效	低成本实现
	悲观锁	差	可能导致锁表	极端场景
zk	顺序节点	中	性能、可靠一般	性能、可靠的兼顾选择
redis	setNx	低	锁没有唯一标示	简单但不推荐
	lua脚本	最高	用不好效果更差	大神选用不是大神用redisson
	redisson	中高	平衡做的好	关注性能

二、MySQL实现分布式锁原理

1、乐观锁实现方式

通过在mysql加入version或者updatetime时间戳的方式实现。下面主要介绍新增流程，修改的更简单不做介绍。乐观锁实现出现事务回滚的时候要处理掉新增场景中无效数据。乐观锁其实并没有用到锁的概念，其实他是一个版本同步的技巧实现。
version-新增实现：在数据库新增的时候先新增一条数据，然后读取这个数据返回给修改页面，当修改页面提交的时候version对比如果一致说明数据合法，如果不一致说明数据不合法。然后version自增写入数据库。
updatetime-新增实现：同version规则一致。
乐观锁无法解决的问题：乐观锁无法解决并发多线程问题，这种适合解决并发比较低的场景的数据库数据一致性问题。

2、悲观锁实现

悲观锁实现：悲观锁实现简单 select * from table for update,悲观锁是所有锁中理论最靠谱的一种，但是性能差。在并发场景不推荐使用;
悲观锁的问题：性能问题、导致锁表

三、ZooKeeper实现分布式锁原理

1、Curator Recipes实现哪些锁

• InterProcessMutex：可重入、独占锁InterProcessSemaphoreMutex：不可重入、独占锁
• InterProcessReadWriteLock：读写锁
• InterProcessSemaphoreV2 ： 共享信号量
• InterProcessMultiLock：多重共享锁 （将多个锁作为单个实体管理的容器）

2、ZooKeeper分布式锁实现

  org.apache.curator
  curator-recipes
  2.12.0


/**
 * 功能：zk - zk Curator客户端 - 实现分布式锁测试
 * 作者：丁志超
 */  
public class ZkCuratorLock{  
	
	//实例化客户端
	private static RetryPolicy retryPolicy  = new ExponentialBackoffRetry(1000,3);
    private static CuratorFramework client = CuratorFrameworkFactory.builder()
            .connectString("ip:2181")
            .sessionTimeoutMs(3000)
            .connectionTimeoutMs(5000)
            .retryPolicy(retryPolicy)
            .build();
    
    //zk分布式锁创建节点在零时目录zklock下创建
    static String lockPath = "/zklock";
    //实例化分布式锁
    final static InterProcessLock lock = new InterProcessSemaphoreMutex(client, lockPath);
	
	
	public static void main(String[] args) {
		//获取锁
		try {
			lock.acquire();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			//释放锁
			try {
				lock.release();
			} catch (Exception e) {
			}
		}
	}
	
} 

3、ZooKeeper分布式事务原理

ZooKeeper实现分布式事务的原理，是基于ZooKeeper顺序节点特性实现的。

• 创建一个锁目录lock
• 线程A获取锁会在lock目录下，创建临时顺序节点
• 获取锁目录下所有的子节点，然后获取比自己小的兄弟节点，如果不存在，则说明当前线程顺序号最小获得锁
• 线程B创建临时节点并获取所有兄弟节点，只监听当前获取锁的节点的变化，节约效率。
• 线程A处理完，删除自己的节点，线程B监听到变更事件，判断自己是最小的节点获得锁

由于节点的临时属性，如果创建znode的那个客户端崩溃了，那么相应的znode会被自动删除。这样就避免了设置过期时间的问题，Curator客户端是基于顺序节点实现的分布式锁。

4、ZooKeeper分布式锁面临问题

1、是否有脑裂问题？

由于zookeeper是基于Ha方式部署的，其写全部在主节点进行，只要主节点服务正常就不会出现脑裂问题。

2、心跳超时问题？

由于zookeeper客户端与服务端session保持会话需要心跳机制保证。如果客户端或者服务端GC导致心跳超时，此时零时节点会被zookeeper全部踢掉。zookeeper的零时节点绑定在会话session上面，session不存在客户端创建的零时节点全部会被删除。

5、ZooKeeper Curator实现分布式锁源码分析

//1、Curator锁数据结构
private static class LockData
{
        //当前拥有锁的线程
        final Thread owningThread;
        //当前锁的路径
        final String lockPath;
        //锁计数器
        final AtomicInteger lockCount = new AtomicInteger(1);
 }


//2、这段是Curator的精华 - 获取锁成功后验证 及 获取锁失败后等待
private boolean internalLockLoop(long startMillis, Long millisToWait, String ourPath) throws Exception
    {
        boolean     haveTheLock = false;
        boolean     doDelete = false;
        try
        {
            if ( revocable.get() != null )
            {
                client.getData().usingWatcher(revocableWatcher).forPath(ourPath);
            }

            while ( (client.getState() == CuratorFrameworkState.STARTED) && !haveTheLock )
            {
                List        children = getSortedChildren();
                String              sequenceNodeName = ourPath.substring(basePath.length() + 1); // +1 to include the slash
                
                //成功获取锁
                PredicateResults    predicateResults = driver.getsTheLock(client, children, sequenceNodeName, maxLeases);
                if ( predicateResults.getsTheLock() )
                {
                    haveTheLock = true;
                }
                else
                {
                    //没有获取锁，监听拥有锁节点的变化
                    String  previousSequencePath = basePath + "/" + predicateResults.getPathToWatch();
                    
                    //获取锁失败后等待超时如果不设置超时一直等待
                    synchronized(this)
                    {
                        try 
                        {
                            // use getData() instead of exists() to avoid leaving unneeded watchers which is a type of resource leak
                            client.getData().usingWatcher(watcher).forPath(previousSequencePath);
                            if ( millisToWait != null )
                            {
                                millisToWait -= (System.currentTimeMillis() - startMillis);
                                startMillis = System.currentTimeMillis();
                                if ( millisToWait <= 0 )
                                {
                                    doDelete = true;    // timed out - delete our node
                                    break;
                                }

                                wait(millisToWait);
                            }
                            else
                            {
                                wait();
                            }
                        }
                        catch ( KeeperException.NoNodeException e ) 
                        {
                            // it has been deleted (i.e. lock released). Try to acquire again
                        }
                    }
                }
            }
        }
        catch ( Exception e )
        {
            ThreadUtils.checkInterrupted(e);
            doDelete = true;
            throw e;
        }
        finally
        {
            if ( doDelete )
            {
                deleteOurPath(ourPath);
            }
        }
        return haveTheLock;
    }
    
//3、获取锁算法思想 - maxLeases默认值是1，要求获取锁的线程永远是list的第一个线程，保证获取锁顺序性
public PredicateResults getsTheLock(CuratorFramework client, List children, String sequenceNodeName, int maxLeases) throws Exception
    {
        int             ourIndex = children.indexOf(sequenceNodeName);
        validateOurIndex(sequenceNodeName, ourIndex);

        boolean         getsTheLock = ourIndex < maxLeases;
        String          pathToWatch = getsTheLock ? null : children.get(ourIndex - maxLeases);

        return new PredicateResults(pathToWatch, getsTheLock);
    }
    

四、Redis实现分布式锁

1、Redisson支持哪些分布式锁

• RedissonLock 功能常见常用的获取非公平锁的类
• RedissonMultiLock 功能是一个方法有很多锁构成，把这些锁统一管理
• RedissonSpinLock 功能是自旋方式获取锁的RedissonReadLock
• RedissonWriteLock 功能redisson实现的读写锁 读实现：hget 写：setNx
• RedissonRedLock 功能与RedissonMultiLock相似

2、Redis分布式锁实现

1、Redis SetNx实现

//setNx实现分布式锁
public class SetNxLock {
		public static void main(String[] args) {
			Jedis jedis = new Jedis("localhost");
			jedis.setnx("key", "value");
			try {
				if(jedis.exists("key")) {
					jedis.expire("key", 10);
					System.out.println("我获取了锁，干点活！");
					jedis.del("key");
				}
			} catch (Exception e) {
				
			} finally {
				jedis.del("key");
			}
		}
}  

2、Redis lua脚本实现

/**
 * 功能：redis - lua - lua实现分布式锁 使用redis.clients客户端
 * 作者：丁志超
 */  
public class LuaLock {

		public static void main(String[] args) {
			 lock("122333", "33331","10000" );
			 unlock("122333", "33331");
	}
		
	/**
	 * 加锁语法
	 * key:redis key
	 * value:redis value
	 * time: redis timeouts 锁过期时间一般大于最耗时的业务消耗的时间 
	 * 语法参考文档：https://www.runoob.com/redis/redis-scripting.html
	 * */	
	public static String lock(String key, String value,String timeOut ) {
			/**
	         *  -- 加锁脚本，其中KEYS[]为外部传入参数
	         *  -- KEYS[1]表示key 
	         *  -- ARGV[1]表示value
	         *  -- ARGV[2]表示过期时间
	         */
		    String lua_getlock_script = "if redis.call('SETNX','"+key+"','"+value+"') == 1 then" +
                "     return redis.call('pexpire','"+key+"','"+timeOut+"')" +
                " else" +
                "     return 0 " +
                "end";
			
			Jedis jedis = new Jedis("localhost");
			//在缓存中添加脚本但不执行
			String scriptId = jedis.scriptLoad(lua_getlock_script);
			//查询脚本是否添加
			Boolean isExists = jedis.scriptExists(scriptId);
			//执行脚本 返回1表示成功，返回0表示失败
			Object num = jedis.eval(lua_getlock_script);;
			return String.valueOf(num);
	}
	
	
	
	/**
	 * 释放锁语法
	 * key:redis key
	 * value:redis value
	 * time: redis timeouts 锁过期时间一般大于最耗时的业务消耗的时间 
	 * 语法参考文档：https://www.runoob.com/redis/redis-scripting.html
	 * */	
	public static String unlock(String key, String value ) {
			/**
	         *  -- 加锁脚本，其中KEYS[]为外部传入参数
	         *  -- KEYS[1]表示key 
	         *  -- ARGV[1]表示value
	         *  -- ARGV[2]表示过期时间
	         */
		    String lua_unlock_script  =
		              "if redis.call('get','"+key+"') == '"+value+"' then " +
		                      " return redis.call('del','"+key+"') " +
		                      "else  return 0 " +
		                      "end";
			
			Jedis jedis = new Jedis("localhost");
			//在缓存中添加脚本但不执行
			String scriptId = jedis.scriptLoad(lua_unlock_script);
			//查询脚本是否添加
			Boolean isExists = jedis.scriptExists(scriptId);
			//执行脚本 返回1表示成功，返回0表示失败
			Object num = jedis.eval(lua_unlock_script);;
			return String.valueOf(num);
	}
}  

3、Redis Redisson实现

/**
 * 功能：redis - Redisson - Redisson实现分布式锁
 * 作者：丁志超
 */  
public class RedissonLock {

	public static void main(String[] args) {
		Config config = new Config(); 
     	config.useSingleServer().setAddress("localhost");
     	RedissonClient redissonClient = Redisson.create(config);
		RLock rLock = redissonClient.getLock("key");
		try {
			rLock.tryLock(10, TimeUnit.SECONDS);
			System.out.println("我获取了锁，该我干活了。");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(rLock.isLocked()) {
				rLock.unlock();
			}
		}
		
	}
}  

3、单节点redis分布式实现原理

1、单节点setNx、lua脚本分布式锁实现原理

setNx线程模型：setNx线程模型必须是单线程（包括接收、解析、处理线程），才能保证其没有并发问题。这个猜想没有找到源码及相关文档的证明。redis线程模型文章

SET resource_name my_random_value NX PX 30000

lua脚本：lua脚本其实就是一个类似于mysql的存储过程，其最大的意义是降低网络交互。性能要优于单独使用redis命令。

if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end

2、Redisson分布式锁实现原理

//redisson锁实体数据结构
public class RedissonLockEntry  {
    
    //计数器
    private int counter;
    
    //信号类 控制多少线程同时获取锁
    private final Semaphore latch;
    private final RPromise promise;
    //线程队列
    private final ConcurrentLinkedQueue listeners = new ConcurrentLinkedQueue();
}


//源码类位置 redisson RedissonLock.class
//redisson实现分布式锁源码解析
public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
        long time = unit.toMillis(waitTime);
        long current = System.currentTimeMillis();
        long threadId = Thread.currentThread().getId();
        //尝试获取锁其实现见后面的方法
        Long ttl = tryAcquire(waitTime, leaseTime, unit, threadId);
        // lock acquired
        if (ttl == null) {
            return true;
        }
        
        //如果锁超时直接返回失败
        time -= System.currentTimeMillis() - current;
        if (time <= 0) {
            acquireFailed(waitTime, unit, threadId);
            return false;
        }
        
        
        current = System.currentTimeMillis();   
        //通过线程ID获取锁结构体
        RFuture subscribeFuture = subscribe(threadId);
        if (!subscribeFuture.await(time, TimeUnit.MILLISECONDS)) {
            if (!subscribeFuture.cancel(false)) {
                subscribeFuture.onComplete((res, e) -> {
                    if (e == null) {
                        unsubscribe(subscribeFuture, threadId);
                    }
                });
            }
            acquireFailed(waitTime, unit, threadId);
            return false;
        }

        try {
            //再次检查锁是否超时，如果超时释放锁
            time -= System.currentTimeMillis() - current;
            if (time <= 0) {
                acquireFailed(waitTime, unit, threadId);
                return false;
            }
            
            //在非超时周期内通过自旋方式获取锁
            while (true) {
                long currentTime = System.currentTimeMillis();
                ttl = tryAcquire(waitTime, leaseTime, unit, threadId);
                // lock acquired
                if (ttl == null) {
                    return true;
                }
                
                //超时释放锁
                time -= System.currentTimeMillis() - currentTime;
                if (time <= 0) {
                    acquireFailed(waitTime, unit, threadId);
                    return false;
                }

                // waiting for message
                currentTime = System.currentTimeMillis();
                if (ttl >= 0 && ttl < time) {
                    subscribeFuture.getNow().getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                } else {
                    subscribeFuture.getNow().getLatch().tryAcquire(time, TimeUnit.MILLISECONDS);
                }

                time -= System.currentTimeMillis() - currentTime;
                if (time <= 0) {
                    acquireFailed(waitTime, unit, threadId);
                    return false;
                }
            }
        } finally {
            unsubscribe(subscribeFuture, threadId);
        }
//        return get(tryLockAsync(waitTime, leaseTime, unit));
    }


//redisson获取锁最底层实现，使用lua脚本实现，如果有key返回key的剩余生命时间
 RFuture tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand command) {
        return evalWriteAsync(getRawName(), LongCodec.INSTANCE, command,
                //若 key 存在返回 1 ，否则返回 0               
                "if (redis.call('exists', KEYS[1]) == 0) then " +
                        //给key增加超时时间    
                        "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                        //设置key的生命周期      
                        "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                        "return nil; " +
                        "end; " +
                        //查询key存在      
                        "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                        "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                        "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                        "return nil; " +
                        "end; " +
                        "return redis.call('pttl', KEYS[1]);",
                Collections.singletonList(getRawName()), unit.toMillis(leaseTime), getLockName(threadId));
} 

//释放锁
@Override
protected RFuture acquireFailedAsync(long waitTime, TimeUnit unit, long threadId) {
        long wait = threadWaitTime;
        if (waitTime != -1) {
            wait = unit.toMillis(waitTime);
        }

        //这块看的有点懵，等学习lua在看
        return evalWriteAsync(getRawName(), LongCodec.INSTANCE, RedisCommands.EVAL_VOID,
                // 移除list超时的key及对应的线程
                "local queue = redis.call('lrange', KEYS[1], 0, -1);" +
                // find the location in the queue where the thread is
                "local i = 1;" +
                "while i <= #queue and queue[i] ~= ARGV[1] do " +
                    "i = i + 1;" +
                "end;" +
                // go to the next index which will exist after the current thread is removed
                "i = i + 1;" +
                // decrement the timeout for the rest of the queue after the thread being removed
                "while i <= #queue do " +
                    "redis.call('zincrby', KEYS[2], -tonumber(ARGV[2]), queue[i]);" +
                    "i = i + 1;" +
                "end;" +
                // remove the thread from the queue and timeouts set
                //移除超时的线程              
                "redis.call('zrem', KEYS[2], ARGV[1]);" +
                "redis.call('lrem', KEYS[1], 0, ARGV[1]);",
                Arrays.