redis实现分布式锁工具类 灰常好用

public interface RedisDistributionLock {
    /** 
       * 加锁成功，返回加锁时间 
       * @param lockKey 
       * @param threadName 
       * @return 
       */ 
      public long lock(String lockKey, String threadName); 
      
      /** 
       * 解锁， 需要更新加锁时间，判断是否有权限 
       * @param lockKey 
       * @param lockValue 
       * @param threadName 
       */ 
      public void unlock(String lockKey, long lockValue, String threadName); 
      
      /** 
       * 多服务器集群，使用下面的方法，代替System.currentTimeMillis()，获取redis时间，避免多服务的时间不一致问题！！！ 
       * @return 
       */ 
      public long currtTimeForRedis(); 
}

import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;

public class RedisLockImpl implements RedisDistributionLock{
    //加锁超时时间，单位毫秒， 即：加锁时间内执行完操作，如果未完成会有并发现象 
      private static final long LOCK_TIMEOUT = 5*1000; 
      
      private static final Logger LOG = LoggerFactory.getLogger(RedisLockImpl.class); 
      
      private StringRedisTemplate redisTemplate; 
      
      public RedisLockImpl(StringRedisTemplate redisTemplate) { 
        this.redisTemplate = redisTemplate; 
      } 
      
      /** 
       * 加锁 
       * 取到锁加锁，取不到锁一直等待知道获得锁 
       * @param lockKey 
       * @param threadName 
       * @return 
       */
      @Override
      public synchronized long lock(String lockKey, String threadName) { 
//        LOG.info(threadName+"开始执行加锁"); 
        while (true){ //循环获取锁 
          //锁时间 
          Long lock_timeout = currtTimeForRedis()+ LOCK_TIMEOUT +1; 
          if (redisTemplate.execute(new RedisCallback<Boolean>() { 
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException { 
              //定义序列化方式 
              RedisSerializer<String> serializer = redisTemplate.getStringSerializer(); 
              byte[] value = serializer.serialize(lock_timeout.toString()); 
              boolean flag = redisConnection.setNX(lockKey.getBytes(), value); 
              return flag; 
            } 
          })){ 
            //如果加锁成功 
//            LOG.info(threadName +"加锁成功 ++++ 111111"); 
            //设置超时时间，释放内存 
            redisTemplate.expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS); 
            return lock_timeout; 
          }else { 
            //获取redis里面的时间 
            String result = redisTemplate.opsForValue().get(lockKey); 
            Long currt_lock_timeout_str = result==null?null:Long.parseLong(result); 
            //锁已经失效 
            if (currt_lock_timeout_str != null && currt_lock_timeout_str < System.currentTimeMillis()){ 
              //判断是否为空，不为空时，说明已经失效，如果被其他线程设置了值，则第二个条件判断无法执行 
              //获取上一个锁到期时间，并设置现在的锁到期时间 
              Long old_lock_timeout_Str = Long.valueOf(redisTemplate.opsForValue().getAndSet(lockKey, lock_timeout.toString())); 
              if (old_lock_timeout_Str != null && old_lock_timeout_Str.equals(currt_lock_timeout_str)){ 
                //多线程运行时，多个线程签好都到了这里，但只有一个线程的设置值和当前值相同，它才有权利获取锁 
//                LOG.info(threadName + "加锁成功 ++++ 22222"); 
                //设置超时间，释放内存 
                redisTemplate.expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS); 
      
                //返回加锁时间 
                return lock_timeout; 
              } 
            } 
          } 
      
          try { 
//            LOG.info(threadName +"等待加锁， 睡眠100毫秒"); 
//            TimeUnit.MILLISECONDS.sleep(100); 
            TimeUnit.MILLISECONDS.sleep(200); 
          } catch (InterruptedException e) { 
            e.printStackTrace(); 
          } 
        } 
      } 
      
      /** 
       * 解锁 
       * @param lockKey 
       * @param lockValue 
       * @param threadName 
       */
      @Override
      public synchronized void unlock(String lockKey, long lockValue, String threadName) { 
        LOG.info(threadName + "执行解锁==========");//正常直接删除 如果异常关闭判断加锁会判断过期时间 
        //获取redis中设置的时间 
        String result = redisTemplate.opsForValue().get(lockKey); 
        Long currt_lock_timeout_str = result ==null?null:Long.valueOf(result); 
      
        //如果是加锁者，则删除锁， 如果不是，则等待自动过期，重新竞争加锁 
        if (currt_lock_timeout_str !=null && currt_lock_timeout_str == lockValue){ 
          redisTemplate.delete(lockKey); 
          LOG.info(threadName + "解锁成功------------------"); 
        } 
      } 
      
      /** 
       * 多服务器集群，使用下面的方法，代替System.currentTimeMillis()，获取redis时间，避免多服务的时间不一致问题！！！ 
       * @return 
       */
      @Override
      public long currtTimeForRedis(){ 
        return redisTemplate.execute(new RedisCallback<Long>() { 
          @Override
          public Long doInRedis(RedisConnection redisConnection) throws DataAccessException { 
            return redisConnection.time(); 
          } 
        }); 
      } 
}

// 创建一个redis分布式锁
private static final String LOCK_NO = "redis_distribution_lock_no1";

        RedisLockImpl redisLock = new RedisLockImpl(stringRedisTemplate);
        // 加锁时间
        Long lockTime;
        String name = "uuid";
        if ((lockTime = redisLock.lock((LOCK_NO) + "", name)) != null) {
            // 业务逻辑
            redisLock.unlock((LOCK_NO) + "", lockTime, name);
        }

工具类。