Redis实现分布式锁的几种方法总结

Redis实现分布式锁的几种方法总结

分布式锁是控制分布式系统之间同步访问共享资源的一种方式。在分布式系统中,常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源,那么访问这些资源的时候,往往需要互斥来防止彼此干扰来保证一致性,在这种情况下,便需要使用到分布式锁。

我们来假设一个最简单的秒杀场景:数据库里有一张表,column分别是商品ID,和商品ID对应的库存量,秒杀成功就将此商品库存量-1。现在假设有1000个线程来秒杀两件商品,500个线程秒杀第一个商品,500个线程秒杀第二个商品。我们来根据这个简单的业务场景来解释一下分布式锁。

通常具有秒杀场景的业务系统都比较复杂,承载的业务量非常巨大,并发量也很高。这样的系统往往采用分布式的架构来均衡负载。那么这1000个并发就会是从不同的地方过来,商品库存就是共享的资源,也是这1000个并发争抢的资源,这个时候我们需要将并发互斥管理起来。这就是分布式锁的应用。

1.实现分布式锁的几种方案

1.Redis实现   (推荐)
    2.Zookeeper实现
    3.数据库实现

Redis实现分布式锁
*
* 在集群等多服务器中经常使用到同步处理一下业务,这是普通的事务是满足不了业务需求,需要分布式锁
*
* 分布式锁的常用3种实现:
*        0.数据库乐观锁实现
*        1.Redis实现  --- 使用redis的setnx()、get()、getset()方法,用于分布式锁,解决死锁问题
*        2.Zookeeper实现
*           参考:http://surlymo.iteye.com/blog/2082684
*              http://www.jb51.net/article/103617.htm
*              http://www.hollischuang.com/archives/1716?utm_source=tuicool&utm_medium=referral
*          1、实现原理:
基于zookeeper瞬时有序节点实现的分布式锁,其主要逻辑如下(该图来自于IBM网站)。大致思想即为:每个客户端对某个功能加锁时,在zookeeper上的与该功能对应的指定节点的目录下,生成一个唯一的瞬时有序节点。判断是否获取锁的方式很简单,只需要判断有序节点中序号最小的一个。当释放锁的时候,只需将这个瞬时节点删除即可。同时,其可以避免服务宕机导致的锁无法释放,而产生的死锁问题。
2、优点
锁安全性高,zk可持久化
3、缺点
性能开销比较高。因为其需要动态产生、销毁瞬时节点来实现锁功能。
4、实现
可以直接采用zookeeper第三方库curator即可方便地实现分布式锁
*
* Redis实现分布式锁的原理:
*  1.通过setnx(lock_timeout)实现,如果设置了锁返回1, 已经有值没有设置成功返回0
*  2.死锁问题:通过实践来判断是否过期,如果已经过期,获取到过期时间get(lockKey),然后getset(lock_timeout)判断是否和get相同,
*   相同则证明已经加锁成功,因为可能导致多线程同时执行getset(lock_timeout)方法,这可能导致多线程都只需getset后,对于判断加锁成功的线程,
*   再加expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS)过期时间,防止多个线程同时叠加时间,导致锁时效时间翻倍
*  3.针对集群服务器时间不一致问题,可以调用redis的time()获取当前时间

2.Redis分分布式锁的代码实现

1.定义锁接口

package com.jay.service.redis; 

/**
 * Redis分布式锁接口
 * Created by hetiewei on 2017/4/7.
 */
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();
}

   2.定义锁实现

package com.jay.service.redis.impl; 

import com.jay.service.redis.RedisDistributionLock;
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; 

import java.util.concurrent.TimeUnit; 

/**
 * Created by hetiewei on 2017/4/7.
 */
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();
      }
    });
  } 

}

  3.分布式锁验证     

@RestController
@RequestMapping("/distribution/redis")
public class RedisLockController { 

  private static final String LOCK_NO = "redis_distribution_lock_no_"; 

  private static int i = 0; 

  private ExecutorService service; 

  @Autowired
  private StringRedisTemplate redisTemplate; 

  /**
   * 模拟1000个线程同时执行业务,修改资源
   *
   * 使用线程池定义了20个线程
   *
   */
  @GetMapping("lock1")
  public void testRedisDistributionLock1(){ 

    service = Executors.newFixedThreadPool(20); 

    for (int i=0;i<1000;i++){
      service.execute(new Runnable() {
        @Override
        public void run() {
          task(Thread.currentThread().getName());
        }
      });
    } 

  } 

  @GetMapping("/{key}")
  public String getValue(@PathVariable("key") String key){
    Serializable result = redisTemplate.opsForValue().get(key);
    return result.toString();
  } 

  private void task(String name) {
//    System.out.println(name + "任务执行中"+(i++)); 

    //创建一个redis分布式锁
    RedisLockImpl redisLock = new RedisLockImpl(redisTemplate);
    //加锁时间
    Long lockTime;
    if ((lockTime = redisLock.lock((LOCK_NO+1)+"", name))!=null){
      //开始执行任务
      System.out.println(name + "任务执行中"+(i++));
      //任务执行完毕 关闭锁
      redisLock.unlock((LOCK_NO+1)+"", lockTime, name);
    } 

  }
}

4.结果验证:

在Controller中模拟了1000个线程,通过线程池方式提交,每次20个线程抢占分布式锁,抢到分布式锁的执行代码,没抢到的等待

结果如下:

2017-04-07 16:27:17.385 INFO 8652 --- [pool-2-thread-4] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-4等待加锁, 睡眠100毫秒
2017-04-07 16:27:17.385 INFO 8652 --- [pool-2-thread-7] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-7解锁成功------------------
    2017-04-07 16:27:17.391 INFO 8652 --- [pool-2-thread-5] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-5加锁成功 ++++ 111111
pool-2-thread-5任务执行中994
2017-04-07 16:27:17.391 INFO 8652 --- [pool-2-thread-5] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-5执行解锁==========
    2017-04-07 16:27:17.391 INFO 8652 --- [pool-2-thread-1] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-1等待加锁, 睡眠100毫秒
2017-04-07 16:27:17.391 INFO 8652 --- [pool-2-thread-5] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-5解锁成功------------------
    2017-04-07 16:27:17.397 INFO 8652 --- [pool-2-thread-6] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-6加锁成功 ++++ 111111
pool-2-thread-6任务执行中995
2017-04-07 16:27:17.398 INFO 8652 --- [pool-2-thread-6] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-6执行解锁==========
    2017-04-07 16:27:17.398 INFO 8652 --- [pool-2-thread-6] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-6解锁成功------------------
    2017-04-07 16:27:17.400 INFO 8652 --- [ool-2-thread-19] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-19加锁成功 ++++ 111111
pool-2-thread-19任务执行中996
2017-04-07 16:27:17.400 INFO 8652 --- [ool-2-thread-19] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-19执行解锁==========
    2017-04-07 16:27:17.400 INFO 8652 --- [ool-2-thread-19] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-19解锁成功------------------
    2017-04-07 16:27:17.571 INFO 8652 --- [ool-2-thread-11] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-11加锁成功 ++++ 111111
pool-2-thread-11任务执行中997
2017-04-07 16:27:17.572 INFO 8652 --- [ool-2-thread-11] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-11执行解锁==========
    2017-04-07 16:27:17.572 INFO 8652 --- [ool-2-thread-11] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-11解锁成功------------------
    2017-04-07 16:27:17.585 INFO 8652 --- [pool-2-thread-4] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-4加锁成功 ++++ 111111
pool-2-thread-4任务执行中998
2017-04-07 16:27:17.586 INFO 8652 --- [pool-2-thread-4] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-4执行解锁==========
    2017-04-07 16:27:17.586 INFO 8652 --- [pool-2-thread-4] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-4解锁成功------------------
    2017-04-07 16:27:17.591 INFO 8652 --- [pool-2-thread-1] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-1加锁成功 ++++ 111111
pool-2-thread-1任务执行中999
2017-04-07 16:27:17.591 INFO 8652 --- [pool-2-thread-1] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-1执行解锁==========
    2017-04-07 16:27:17.591 INFO 8652 --- [pool-2-thread-1] c.jay.service.redis.impl.RedisLockImpl  : pool-2-thread-1解锁成功------------------

感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

(0)

相关推荐

  • 详解Java如何实现基于Redis的分布式锁

    前言 单JVM内同步好办, 直接用JDK提供的锁就可以了,但是跨进程同步靠这个肯定是不可能的,这种情况下肯定要借助第三方,我这里实现用Redis,当然还有很多其他的实现方式.其实基于Redis实现的原理还算比较简单的,在看代码之前建议大家先去看看原理,看懂了之后看代码应该就容易理解了. 我这里不实现JDK的java.util.concurrent.locks.Lock接口,而是自定义一个,因为JDK的有个newCondition方法我这里暂时没实现.这个Lock提供了5个lock方法的变体,可以

  • redis实现加锁的几种方法示例详解

    前言 本文主要给大家介绍了关于redis实现加锁的几种方法,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧. 1. redis加锁分类 redis能用的的加锁命令分表是INCR.SETNX.SET 2. 第一种锁命令INCR 这种加锁的思路是, key 不存在,那么 key 的值会先被初始化为 0 ,然后再执行 INCR 操作进行加一. 然后其它用户在执行 INCR 操作进行加一时,如果返回的数大于 1 ,说明这个锁正在被使用当中. 1. 客户端A请求服务器获取key的值为1表示

  • 基于Redis实现分布式锁以及任务队列

    一.前言 双十一刚过不久,大家都知道在天猫.京东.苏宁等等电商网站上有很多秒杀活动,例如在某一个时刻抢购一个原价1999现在秒杀价只要999的手机时,会迎来一个用户请求的高峰期,可能会有几十万几百万的并发量,来抢这个手机,在高并发的情形下会对数据库服务器或者是文件服务器应用服务器造成巨大的压力,严重时说不定就宕机了,另一个问题是,秒杀的东西都是有量的,例如一款手机只有10台的量秒杀,那么,在高并发的情况下,成千上万条数据更新数据库(例如10台的量被人抢一台就会在数据集某些记录下 减1),那次这个

  • Redis数据库中实现分布式锁的方法

    分布式锁是一个在很多环境中非常有用的原语,它是不同进程互斥操作共享资源的唯一方法.有很多的开发库和博客描述如何使用Redis实现DLM(Distributed Lock Manager),但是每个开发库使用不同的方式,而且相比更复杂的设计与实现,很多库使用一些简单低可靠的方式来实现. 这篇文章尝试提供更标准的算法来使用Redis实现分布式锁.我们提出一种算法,叫做Relock,它实现了我们认为比vanilla单一实例方式更安全的DLM(分布式锁管理).我们希望社区分析它并提供反馈,以做为更加复杂

  • Redis上实现分布式锁以提高性能的方案研究

    背景: 在很多互联网产品应用中,有些场景需要加锁处理,比如:秒杀,全局递增ID,楼层生成等等.大部分是解决方案基于DB实现的,Redis为单进程单线程模式,采用队列模式将并发访问变成串行访问,且多客户端对Redis的连接并不存在竞争关系. 项目实践 任务队列用到分布式锁的情况比较多,在将业务逻辑中可以异步处理的操作放入队列,在其他线程中处理后出队,此时队列中使用了分布式锁,保证入队和出队的一致性.关于redis队列这块的逻辑分析,我将在下一次对其进行总结,此处先略过. 接下来对redis实现的分

  • redis中使用java脚本实现分布式锁

    redis被大量用在分布式的环境中,自然而然分布式环境下的锁如何解决,立马成为一个问题.例如我们当前的手游项目,服务器端是按业务模块划分服务器的,有应用服,战斗服等,但是这两个vm都有可能同时改变玩家的属性,这如果在同一个vm下面,就很容易加锁,但如果在分布式环境下就没那么容易了,当然利用redis现有的功能也有解决办法,比如redis的脚本. redis在2.6以后的版本中增加了Lua脚本的功能,可以通过eval命令,直接在RedisServer环境中执行Lua脚本,并且可以在Lua脚本中调用

  • Redis实现分布式锁的几种方法总结

    Redis实现分布式锁的几种方法总结 分布式锁是控制分布式系统之间同步访问共享资源的一种方式.在分布式系统中,常常需要协调他们的动作.如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源,那么访问这些资源的时候,往往需要互斥来防止彼此干扰来保证一致性,在这种情况下,便需要使用到分布式锁. 我们来假设一个最简单的秒杀场景:数据库里有一张表,column分别是商品ID,和商品ID对应的库存量,秒杀成功就将此商品库存量-1.现在假设有1000个线程来秒杀两件商品,500个线程秒杀第一个商品,

  • 基于redis实现分布式锁的原理与方法

    前言 系统的不断扩大,分布式锁是最基本的保障.与单机的多线程不一样的是,分布式跨多个机器.线程的共享变量无法跨机器. 为了保证一个在高并发存场景下只能被同一个线程操作,java并发处理提供ReentrantLock或Synchronized进行互斥控制.但是这仅仅对单机环境有效.我们实现分布式锁大概通过三种方式. redis实现分布式锁 数据库实现分布式锁 zk实现分布式锁 今天我们介绍通过redis实现分布式锁.实际上这三种和java对比看属于一类.都是属于程序外部锁. 原理剖析 上述三种分布

  • 基于Redis的分布式锁的简单实现方法

    Redis官方给出两种思路 第一种:SET key value [EX seconds] [PX milliseconds] NX 第二种:SETNX+GETSET 首先,分别看一下这几个命令 SET命令 SETNX命令 GETSET命令 接着,看第一种方式 官方给出的思路是这样的 还有一处,也是类似的 这种方式的实现可能是这样的: 第二种方式 官方给出的思路是这样的 代码可能看起来像是这样 总结: 这两种方式的基本思路都是:客户端在服务器上设置一个key值,如果能够设置成功,则视为加锁成功:删

  • 浅谈分布式锁的几种使用方式(redis、zookeeper、数据库)

    Q:一个业务服务器,一个数据库,操作:查询用户当前余额,扣除当前余额的3%作为手续费 synchronized lock dblock Q:两个业务服务器,一个数据库,操作:查询用户当前余额,扣除当前余额的3%作为手续费 分布式锁 我们需要怎么样的分布式锁? 可以保证在分布式部署的应用集群中,同一个方法在同一时间只能被一台机器上的一个线程执行. 这把锁要是一把可重入锁(避免死锁) 这把锁最好是一把阻塞锁(根据业务需求考虑要不要这条) 这把锁最好是一把公平锁(根据业务需求考虑要不要这条) 有高可用

  • Redis分布式锁的正确实现方法总结

    分布式锁一般有三种实现方式: 1.数据库乐观锁: 2.基于Redis的分布式锁: 3.基于ZooKeeper的分布式锁. 本文将介绍第二种方式,基于Redis实现分布式锁.虽然网上已经有各种介绍Redis分布式锁实现的博客,然而他们的实现却有着各种各样的问题,为了避免误人子弟,本篇博客将详细介绍如何正确地实现Redis分布式锁. 可靠性 首先,为了确保分布式锁可用,我们至少要确保锁的实现同时满足以下四个条件: 1.互斥性.在任意时刻,只有一个客户端能持有锁. 2.不会发生死锁.即使有一个客户端在

  • SpringBoot中使用redis做分布式锁的方法

    一.模拟问题 最近在公司遇到一个问题,挂号系统是做的集群,比如启动了两个相同的服务,病人挂号的时候可能会出现同号的情况,比如两个病人挂出来的号都是上午2号.这就出现了问题,由于是集群部署的,所以单纯在代码中的方法中加锁是不能解决这种情况的.下面我将模拟这种情况,用redis做分布式锁来解决这个问题. 1.新建挂号明细表 2.在idea上新建项目 下图是创建好的项目结构,上面那个parent项目是其他项目不用管它,和新建的没有关系 3.开始创建controller,service,dao(mapp

  • Java分布式锁的三种实现方案

    方案一:数据库乐观锁 乐观锁通常实现基于数据版本(version)的记录机制实现的,比如有一张红包表(t_bonus),有一个字段(left_count)记录礼物的剩余个数,用户每领取一个奖品,对应的left_count减1,在并发的情况下如何要保证left_count不为负数,乐观锁的实现方式为在红包表上添加一个版本号字段(version),默认为0. 异常实现流程 -- 可能会发生的异常情况 -- 线程1查询,当前left_count为1,则有记录 select * from t_bonus

  • SpringBoot使用Redis实现分布式锁

    前言 在单机应用时代,我们对一个共享的对象进行多线程访问的时候,使用java的synchronized关键字或者ReentrantLock类对操作的对象加锁就可以解决对象的线程安全问题. 分布式应用时代这个方法却行不通了,我们的应用可能被部署到多台机器上,运行在不同的JVM里,一个对象可能同时存在多台机器的内存中,怎样使共享对象同时只被一个线程处理就成了一个问题. 在分布式系统中为了保证一个对象在高并发的情况下只能被一个线程使用,我们需要一种跨JVM的互斥机制来控制共享资源的访问,此时就需要用到

随机推荐

其他