Redis分布式锁的实现

　　前段时间，我在的项目组准备做一个类似美团外卖的拼手气红包【第X个领取的人红包最大】，基本功能实现后，就要考虑这一操作在短时间内多个用户争抢同一资源的并发问题了，类似于很多应用如淘宝、京东的秒杀活动场景。所谓的秒杀就是多个线程对资源进行操作，而实现秒杀，就必须控制线程对资源的争抢。

传统方法

　　而最传统简单暴力的方法就是在秒杀的业务关键代码块外用Java的synchronized关键字锁住，但这种方式下的锁粒度比较高，比如两个线程同时执行秒杀方法，这两个线程操作的是不同的商品，从业务上讲应该是可以同时进行的，而两个线程会去争抢同一个锁，这是没必要的，而且synchronized是线程同步锁，只允许一个进程的一个线程访问，分布式场景下无法控制同步。这时候，分布式锁上场了。

场景

　　论分布式锁，查阅了很多资料，有很多方法可以实现，如zookeeper、redis等等，而他们的共同点都是通过状态值来标识锁，进而通过状态值来实现锁的占用与释放。比如现在有一个秒杀场景，db有一张表，对应有商品ID和库存，秒杀成功库存-1，现有500个线程秒杀商品1，另有500个线程秒杀商品2。通常具有秒杀场景的业务系统都比较复杂，承载的业务量非常巨大，并发量也很高。这样的系统往往采用分布式的架构来均衡负载。那么这1000个并发就会是从不同的地方过来，商品库存就是共享的资源，也是这1000个并发争抢的资源，这个时候我们需要将并发互斥管理起来，把和商品ID相关的字符串作为状态值来标识锁，这样就只有争抢同一商品的线程互斥，不会导致所以线程互斥。

　　下面介绍下redis分布式锁的实现。

实现原理   

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

三个命令  

　　 setNx key value  [key不存在时设置对应value；key已存在不做任何操作；意‘set if not exists’]

　　 get  [key不存在返回nil；key已存在返回值]

getSet  [设置key值为value，并返回key的旧值]

上代码就是一把梭[锁]

 package com.pagoda.eshop.customer.redis.lock;

 /**
  * 分布式锁接口
  * @Author： 小海
  * @Description:
  * @Date: Create in 17:28 2017/11/8
  */
 public interface IRedisLock {

     /**
      * 获取锁
      * @param lockKey
      * @return
      * @throws InterruptedException
      */
     boolean lock(String lockKey) throws InterruptedException;

     /**
      * 释放锁
      * @param lockKey
      */
     void unlock(String lockKey);
 }

 package com.pagoda.eshop.customer.redis.lock.impl;

 import com.pagoda.eshop.customer.redis.lock.IRedisLock;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import redis.clients.jedis.JedisCluster;

 /**
  * 基于redis实现分布式锁
  * 备注-> https://www.cnblogs.com/novaCN/p/6417330.html[类模板/方法模板的配置-电商代码规范]
  * @Author： 小海
  * @Description:
  * @Date: Create in 17:28 2017/11/8
  */
 @Service
 public class RedisLock implements IRedisLock{

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

     @Autowired
     private JedisCluster jedis;

     private String lockKey;

     private static final int DEFAULT_LOOP_INTERVAL_MILLIS = 100;

     /**
      * 锁超时时间,防止线程在入锁以后,无限的执行等待
      */
     private int expireMsecs = 5 * 1000;

     /**
      * 锁等待时间,防止线程饥饿死锁
      */
     private int timeoutMsecs = 10 * 1000;

     /**
      * 锁标识
      */
     private volatile boolean locked = false;

     /**
      * 锁key后缀
      */
     private static final String LOCKKEY_SUFFIX = ":lock";

     private String get(final String key) {
         Object obj = null;
         try {
             obj = jedis.get(key);
         } catch (Exception e) {
             logger.error("get redis error, key : ", key);
         }
         return obj == null ? null : obj.toString();
     }

     /**
      * 若key不存在,将key的值设为value,并返回true
      * 若key已经存在,则setnx不做任何动作,并返回false
      * @param key
      * @param value
      * @return
      */
     private boolean setNX(final String key, final String value) {
         Object obj = null;
         try {
             obj = jedis.setnx(key, value);
         } catch (Exception e) {
             logger.error("setNX redis error, key : ", key);
         }
         return ((Long) obj).intValue() == 0 ? false : true;
     }

     /**
      * 设置现在的锁到期时间并返回上一个锁到期时间
      * @param key
      * @param value
      * @return 上一个锁的到期时间
      */
     private String getSet(final String key, final String value) {
         Object obj = null;
         try {
             obj = jedis.getSet(key, value);
         } catch (Exception e) {
             logger.error("getSet redis error, key : ", key);
         }
         return obj == null ? null : (String) obj;
     }

     /**
      * 获取锁
      *
      * 实现思路:
      * 主要是使用了redis的setnx命令,缓存了锁
      * reids缓存的key是锁的key,所有的共享,value是锁的到期时间
      *
      * 执行过程:
      * 1.通过setnx尝试设置某个key的值,若锁不存在,则返回true,成功获得锁
      * 2.若锁已经存在,则通过get获取锁的到期时间,和当前时间比较,超时的话,则通过getset设置新的值并返回上一个线程锁的到期时间
      * 3.若通过get和getset获取到的线程锁的到期时间一致的话,则返回true,成功获得锁
      * 4.若无法满足1或3的条件,则睡眠一小段时间,一定时间内循环1~3操作,尝试加锁
      * 5.若超出锁等待时间,则返回false,获取锁失败
      *
      * @return 若获得锁,返回true;若执行超时，返回false
      * @throws InterruptedException
      */
     @Override
     public boolean lock(String lockKey) throws InterruptedException {
         lockKey = lockKey + LOCKKEY_SUFFIX;
         int timeout = timeoutMsecs;
         while (timeout >= 0) {
             long expires = System.currentTimeMillis() + expireMsecs + 1;
             // 对加锁做时效性检测,设置锁到期时间
             String expiresStr = String.valueOf(expires);
             if (this.setNX(lockKey, expiresStr)) {
                 // 成功获得锁
                 locked = true;
                 return true;
             }
             // 当前锁的到期时间
             String currentValueStr = this.get(lockKey);
             // 若锁已超时[获取锁的客户端执行时间过长,进程被kill掉,或因为其他异常崩溃,导致无法释放锁,就会造成死锁],则重新加锁
             if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
                 // 如果多个线程同时走到这里,但是走到这里时每个线程拿到的oldValueStr肯定不可能一样
                 String oldValueStr = this.getSet(lockKey, expiresStr);

                 // 如果多个线程同时走到这里,但是只有一个线程的设置值和当前值相同，他才有权利获取锁
                 if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
                     // 成功获得锁
                     locked = true;
                     return true;
                 }
             }
             timeout -= DEFAULT_LOOP_INTERVAL_MILLIS;
             Thread.sleep(DEFAULT_LOOP_INTERVAL_MILLIS);
         }
         return false;
     }

     /**
      * 释放锁
      */
     @Override
     public void unlock(String lockKey) {
         if (locked) {
             jedis.del(lockKey);
             locked = false;
         }
     }
 }

===============后续

致谢：感谢您的阅读！一些问题请跳转自 http://www.cnblogs.com/0201zcr/p/5942748.html