分布式锁(Redis实现)

1.分布式锁解决方案

 1.采用数据库 不建议 性能不好 jdbc

 2.基于Redis实现分布式锁(setnx)setnx也可以存入key,如果存入key成功返回1,如果存入的key已经存在了,返回0.

3.基于Zookeeper实现分布式锁 Zookeeper是一个分布式协调工具,在分布式解决方案中。

多个客户端(jvm),同时在zk上创建相同的一个临时节点,因为临时节点路径是保证唯一,只要谁能够创建节点成功,谁就能够获取到锁,没有创建成功节点,就会进行等待,当释放锁的时候,采用事件通知给客户端重新获取锁的资源。

 

Redis实现分布式锁与Zookeeper实现分布式锁区别

实现分布式锁最终是通过什么方式?(相同点)

在集群环境下,保证只允许有一个jvm进行执行。

从技术上分析(区别)

Redis 是nosql数据,主要特点缓存

Zookeeper是分布式协调工具,主要用于分布式解决方案

 

实现思路( 区别)

核心通过获取锁、释放锁、死锁问题

 

获取锁

Zookeeper

多个客户端(jvm),会在Zookeeper上创建同一个临时节点,因为Zookeeper节点命名路径保证唯一,不允许出现重复,只要谁能够先创建成功,谁能够获取到锁。

Redis

多个客户端(jvm),会在Redis使用setnx命令创建相同的一个key,因为Redis的key保证唯一,不允许出现重复,只要谁能够先创建成功,谁能够获取到锁。

释放锁

Zookeeper使用直接关闭临时节点session会话连接,因为临时节点生命周期与session会话绑定在一块,如果session会话连接关闭的话,该临时节点也会被删除。

这时候客户端使用事件监听,如果该临时节点被删除的话,重新进入盗获取锁的步骤。

Redis在释放锁的时候,为了确保是锁的一致性问题,在删除的redis 的key时候,需要判断同一个锁的id,才可以删除。

共同特征:如何解决死锁现象问题

Zookeeper使用会话有效期方式解决死锁现象。

Redis 是对key设置有效期解决死锁现象

 

性能角度考虑

因为Redis是NoSQL数据库,相对比来说Redis比Zookeeper性能要好。

可靠性

从可靠性角度分析,Zookeeper可靠性比Redis更好。

因为Redis有效期不是很好控制,可能会产生有效期延迟,Zookeeper就不一样,因为Zookeeper临时节点先天性可控的有效期,所以相对来说Zookeeper比Redis更好

 

 

Redis实现的分布式锁,setnx可以存入key,如果存入key成功返回1,如果存入的key已经存在了返回0

    使用setnx命令方式,同时在redis上创建相同的一个key。redis不允许重复key。创建成功的jvm获取锁,创建失败的jvm就等待。

写入时候 有key 返回1 没有key返回0  

在redis中,key 是唯一的!

 set持续的输入 key 的value会一直被覆盖哦  返回值是 ok    

setnx key不存在1 存在0

 删除之后,又可以了哈!

如何释放锁?

执行完操作时候,删除key。 但是 如果此时 redis挂了,或者删除失败,咋办? 解决办法是 给key设置有效期!!!防止死锁问题 (如果代码一直执行不完了,也可以搞定他!)

  综述:执行完,删除key,每个key,都有期

 

多台服务器集群中,只能保证一个jvm进行操作!

 

identifierValue的作用! 防止a线程删除了 b线程刚刚获取到的锁!!自己删除自己的

 

赶紧上代码,注解已经很详细了~

 pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.toov5.redisLock</groupId>
  <artifactId>redisLock</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <dependencies>
  <dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.9.0</version>
		</dependency> 
  </dependencies>
  
</project>

 redis锁

package com.toov5;

import java.util.UUID;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

//基于redis实现分布式锁,核心方法 获取锁、释放锁
public class LockRedis {
    //redis线程池
     private JedisPool jedisPool;
     //需要创建的那个key
     private String redisLockKey = "redis_lock";
     //value是个不能重复的数字 锁的id
     
     
     public LockRedis(JedisPool jedisPool) {
        this.jedisPool=jedisPool;
    }
     
     
     /*
      * @param acquiretimeOut 在获取锁之前超时
      * @param timeOut 在获取锁之后超时
      */
     
     public String getRedisLock(Long acquiretimeOut, Long timeOut){
         Jedis conn = null;
         try {
            //1建立连接 
            conn=jedisPool.getResource();
            //2、定义redis对应key的value (uuid生成) 释放锁时候会用到
            String identifierValue = UUID.randomUUID().toString();
            //3、reids实现分布式锁 有两个超时问题    
             //3.1获取锁之前,如果规定时间内 没有获取到锁 放弃
             //3.2获取锁之后,可以对应有效期。规定时间内 失效
            //4使用循环机制 保证重复进行尝试获取锁(乐观锁)获取不到 则放弃
            //5 使用setnx命令插入对应的redislockkey,判断返回值进行业务 
            int expireLock =(int)(timeOut/1000); //以秒为单位 转换
            Long endTime = System.currentTimeMillis()+acquiretimeOut;
            while (System.currentTimeMillis()<endTime) { //小于结束时间
                //则 获取锁 
                //6、使用setnx命令插入redislockkey,判断返回值
                if (conn.setnx(redisLockKey, identifierValue)==1) {
                    //设置对应key的有效期
                  conn.expire(redisLockKey, expireLock); //时间为int类型的    
                  return identifierValue; //插入成功返回 对应的值  规定时间内去循环获取
                }    
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if (conn != null) {
                conn.close();
            }
        }
         return null; //如果大于了 时间 就放弃了 返回 null 结束掉
        
      
        
     }
     
     
     //释放redis锁
     public void unRedisLock(String identifierValue){
         //两种 1、执行完毕删除
         //如果直接删除,有可能a刚刚获取,却被b删除了 所以保证是自己创建的redislockkey,自己的
         Jedis conn = null;
         conn=jedisPool.getResource();
         try {
             //如果该锁的id等于identifierValue
            if (conn.get(redisLockKey).equals(identifierValue)) {
            System.out.println("释放锁"+Thread.currentThread().getName()+",identifierValue");    
                conn.del(redisLockKey);
            }
        } catch (Exception e) {
            
        }finally{
          if (conn !=null) {
            conn.close();
        }    
        }
         
     }
    
}

 

业务逻辑:

package com.toov5;

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class LockService {
    private static JedisPool pool = null;
 //redis 连接代码
    static {
        JedisPoolConfig config = new JedisPoolConfig();
        // 设置最大连接数
        config.setMaxTotal(200);
        // 设置最大空闲数
        config.setMaxIdle(8);
        // 设置最大等待时间
        config.setMaxWaitMillis(1000 * 100);
        // 在borrow一个jedis实例时,是否需要验证,若为true,则所有jedis实例均是可用的
        config.setTestOnBorrow(true);
        pool = new JedisPool(config, "192.168.91.5", 9001, 3000);
    }
  //创建一个redis锁
    private LockRedis lockRedis = new LockRedis(pool);
    
 //定义一个方法     演示rdis实现分布式锁
    public void seckill(){
    String identifierValue = lockRedis.getRedisLock(5000L, 5000L);//获取到一个随机的返回结果
     if (identifierValue == null) {
        System.out.println(Thread.currentThread().getName()+"获取时间超时,锁获取失败");
        return;
    }
     System.out.println(Thread.currentThread().getName()+",获取锁成功,锁的id"+identifierValue);
     
     //释放锁
     lockRedis.unRedisLock(identifierValue); //表示锁的id
         
     
    }
    
}

线程:

package com.toov5;

public class ThreadRedis extends Thread {
   private LockService lockService;
   
   public ThreadRedis(LockService lockService) {
    this.lockService=lockService;
}
   
     @Override
    public void run() {
        
      lockService.seckill();
    }
    
}

测试:

package com.toov5;

public class RedisLockTest {
   
    public static void main(String[] args) {
     LockService lockService =  new LockService();
     for (int i = 0; i < 50; i++) {
         new ThreadRedis(lockService).start();
    }
     
    } 
    
}

运行结果:

 

 zk也可以通过设置连接超时时间来防止死锁!

 

 

 

三种分布式对比

 

上面几种方式,哪种方式都无法做到完美。就像CAP一样,在复杂性、可靠性、性能等方面无法同时满足,所以,根据不同的应用场景选择最适合自己的才是王道。

 

从理解的难易程度角度(从低到高)

数据库 > 缓存 > Zookeeper

 

从实现的复杂性角度(从低到高)

Zookeeper >= 缓存 > 数据库

 

从性能角度(从高到低)

缓存 > Zookeeper >= 数据库

 

从可靠性角度(从高到低)

Zookeeper > 缓存 > 数据库

 

 

Redis实现分布式锁与Zookeeper实现分布式锁区别

 

使用redis实现分布式锁

 

redis中的set  nx 命令,当key不存在时,才能在redis中将key添加成功,利用该属性可以实现分布式锁,并且redis对于key有失效时间,可以控制当某个客户端加锁成功之后挂掉,导致阻塞的问题。

 

使用Zookeeper实现分布式锁

 

 

多个客户端在Zookeeper上创建一个相同的临时节点,因为临时节点只能允许一个客户端创建成功,那么只要任意一个客户端创建节点成功,谁就成功的获取到锁,当释放锁后,其他客户端同样道理在Zookeeper节点。

 

 

 总结:

相同:  都是保证集群环境下,只有几个jvm进行执行

不同:  redis 是NoSQL数据库,主要特点是做缓存     

            Zookeeper 是分布式协调工具,主要用于分布式解决方案的

      

主要考虑到三个方面  获取锁 释放锁  死锁

   1、获取锁  多个jvm,会在Zookeeper上面创建一个临时节点,谁先创建成功。 节点唯一性

                                       在redis上使用setnx命令创建一个key,谁先创建成功。可以的唯一性

 

   2、释放锁 使用直接关闭临时节点session会话连接。临时节点就会删除。其他客户端事件监听,进入获取锁的环节步骤。

                    为了保证一致性,一定要判断锁的id才可以删除key

 

 3、 防止死锁: Zookeeper会话有效期设置 

                          Redis的key过期时间

 

 

性能角度上: redis比zk要好一些。 毕竟redis是NoSQL数据库,内存中哦。

                       可靠性来说 zk好   以为redis 的有效期不好控制 可能延迟 看代码: 拿到锁了设置有效期  过程有延迟     zk的节点 先天性可控~

 

 

posted @ 2018-11-03 20:51  toov5  阅读(428)  评论(0编辑  收藏  举报