//保存每个线程独有的token
    private static ThreadLocal<String> tokenMap = new ThreadLocal<>();

/**
     * 这个例子还不太完善。  
     * redis实现分布式可重入锁,并不保证在过期时间内完成锁定内的任务，需根据业务逻辑合理分配seconds
     *
     * @param lock
     *            锁的名称
     * @param mseconds
     *            锁定时间，单位 毫秒
     *  token 对于同一个lock,相同的token可以再次获取该锁，不相同的token线程需等待到unlock之后才能获取
     *
     */
    public  boolean lock(final String lock,  int mseconds ,Jedis jedis) {
        // token 对于同一个lock,相同的token可以再次获取该锁，不相同的token线程需等待到unlock之后才能获取
        String token = tokenMap.get();
        if (StringUtil.isBlank(token)) {
            token = UUID.randomUUID().toString().replaceAll("-","");
            tokenMap.set(token);
        }
        boolean flag = false;
        try {
            String ret = jedis.set(lock, token, "NX", "PX", mseconds);
            if (ret == null) {// 该lock的锁已经存在
                String origToken = jedis.get(lock);// 即使lock已经过期也可以
                if (token.equals(origToken) || origToken==null) {
                // token相同默认为同一线程，所以token应该尽量长且随机，保证不同线程的该值不相同
                    ret = jedis.set(lock, token, "NX", "PX", mseconds);//
                    if ("OK".equalsIgnoreCase(ret))
                        flag = true;
                    System.out.println("当前线程 " + token);
                }
            } else if ("OK".equalsIgnoreCase(ret))
                flag = true;
            System.out.println("当前线程 " + token);
        } catch (Exception e) {

        } finally {
            if (jedis != null)
                jedis.close();
        }
        return flag;
    }

 /**
     * redission分布式锁-重试时间 秒为单位
     * @param lockName 锁名
     * @param waitTime  重试时间
     * @param leaseTime 锁过期时间
     * @return
     */
    public boolean tryLock(String lockName,long waitTime,long leaseTime){
        try{
            RLock rLock = redissonClient.getLock(lockName);
            return rLock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
        }catch (Exception e){
            logger.error("redission lock error with waitTime",e);
        }
        return false;
    }

@Override
public void lockInterruptibly(long leaseTime, TimeUnit unit) throws InterruptedException {
    // 1.尝试获取锁
    Long ttl = tryAcquire(leaseTime, unit);
    // 2.获得锁成功
    if (ttl == null) {
        return;
    }
    // 3.等待锁释放，并订阅锁
    long threadId = Thread.currentThread().getId();
    Future<RedissonLockEntry> future = subscribe(threadId);
    get(future);

    try {
        while (true) {
            // 4.重试获取锁
            ttl = tryAcquire(leaseTime, unit);
            // 5.成功获得锁
            if (ttl == null) {
                break;
            }
            // 6.等待锁释放
            if (ttl >= 0) {
                getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
            } else {
                getEntry(threadId).getLatch().acquire();
            }
        }
    } finally {
        // 7.取消订阅
        unsubscribe(future, threadId);
    }
}

public void unlock() {
    // 1.通过 EVAL 和 Lua 脚本执行 Redis 命令释放锁
    Boolean opStatus = commandExecutor.evalWrite(getName(), LongCodec.INSTANCE,
                    RedisCommands.EVAL_BOOLEAN,
                    "if (redis.call(\'exists\', KEYS[1]) == 0) then " +
                        "redis.call(\'publish\', KEYS[2], ARGV[1]); " +
                        "return 1; " +
                    "end;" +
                    "if (redis.call(\'hexists\', KEYS[1], ARGV[3]) == 0) then " +
                        "return nil;" +
                    "end; " +
                    "local counter = redis.call(\'hincrby\', KEYS[1], ARGV[3], -1); " +
                    "if (counter > 0) then " +
                        "redis.call(\'pexpire\', KEYS[1], ARGV[2]); " +
                        "return 0; " +
                    "else " +
                        "redis.call(\'del\', KEYS[1]); " +
                        "redis.call(\'publish\', KEYS[2], ARGV[1]); " +
                        "return 1; "+
                    "end; " +
                    "return nil;",
                    Arrays.<Object>asList(getName(), getChannelName()), 
                            LockPubSub.unlockMessage, internalLockLeaseTime, 
                            getLockName(Thread.currentThread().getId()));
    // 2.非锁的持有者释放锁时抛出异常
    if (opStatus == null) {
        throw new IllegalMonitorStateException(
                "attempt to unlock lock, not locked by current thread by node id: "
                + id + " thread-id: " + Thread.currentThread().getId());
    }
    // 3.释放锁后取消刷新锁失效时间的调度任务
    if (opStatus) {
        cancelExpirationRenewal();
    }

 if (redis.call(\'exists\' KEYS[1]) == 0) then  +  --  exists 判断key是否存在
                  redis.call(\'hset\' KEYS[1] ARGV[2] 1);  +   --如果不存在，hset存哈希表
                  redis.call(\'pexpire\' KEYS[1] ARGV[1]);  + --设置过期时间
                  return nil;  +                            -- 返回null 就是加锁成功
              end;  +
              if (redis.call(\'hexists\' KEYS[1] ARGV[2]) == 1) then  + -- 如果key存在，查看哈希表中是否存在
                  redis.call(\'hincrby\' KEYS[1] ARGV[2] 1);  + -- 给哈希中的key加1，代表重入1次，以此类推
                  redis.call(\'pexpire\' KEYS[1] ARGV[1]);  + -- 重设过期时间
                  return nil;  +
              end;  +
              return redis.call(\'pttl\' KEYS[1]); --如果前面的if都没进去，说明ARGV2 的值不同，也就是不是同                  一线程的锁，这时候直接返回该锁的过期时间

-- 脚本：尝试获得红包，如果成功，则返回json字符串，如果不成功，则返回空
 -- 参数：红包队列名， 已消费的队列名，去重的Map名，用户ID
 -- 返回值：nil 或者 json字符串，包含用户ID：userId，红包ID：id，红包金额：money
 --  jedis.eval(getScript(), 4, hongBaoList, hongBaoConsumedList, hongBaoConsumedMap, "" + j)
        if redis.call(\'hexists\', KEYS[3], KEYS[4]) ~= 0 then
              return nil
              else
              -- 先取出一个小红包
              local hongBao = redis.call(\'rpop\', KEYS[1])
              -- hongbao ： {"Money":9,"Id":8}
                  if hongBao then
                      local x = cjson.decode(hongBao)
                      -- 加入用户ID信息
                      x[\'userId\'] = KEYS[4]
                      local re = cjson.encode(x)
                      -- 把用户ID放到去重的set里
                      redis.call(\'hset\', KEYS[3], KEYS[4], KEYS[4])
                      -- 把红包放到已消费队列里
                      redis.call(\'lpush\', KEYS[2], re)
                  return re;
                  end
              end
          return nil

public void scriptLoad()throws Exception{
        Jedis jedis = new Jedis("localhost");
        //从文件读取lua脚本
        InputStream input = new FileInputStream("return.lua");
        byte[] by = new byte[input.available()];
        input.read(by);
        byte[] scriptBy = jedis.scriptLoad(by);
        String sha1 = new String(scriptBy);
        //直接解析
        String sha2 = jedis.scriptLoad("local key1 = KEYS[1]\n"
            + "local key2 = KEYS[2]\n"
            + "local argv1 = ARGV[1]\n"
            + "return \"key1:\"..key1 ..\" key2:\"..key2.. \" argv1:\"..argv1");
        System.out.println("sha1 : " + sha1);
        System.out.println("sha2 : " + sha2);
        Object obj = jedis.evalsha(sha1, Arrays.asList("value1","value2"), Arrays.asList("value3"));
        System.out.println("执行结果： "+ obj);
    }