学习redis实现分布式锁-----自己的一个理解

一、导入maven依赖

       <dependency>
           <groupId>redis.clients</groupId>
           <artifactId>jedis</artifactId>
           <version>2.9.0</version>
       </dependency>
二、代码实现
import java.util.UUID;

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

/**
* 分布式锁的思想：多个服务器集群下，只允许其中一个jvm进行操作
* redis实现分布式锁的思路:
*
* 获取锁:在多个jvm情况下，redis实现分布式锁通过setnx方法创建同一个key ，
* 这个key是唯一不重复，如果存入成功返回1获取锁，存入失败返回0，value使用一个唯一不重复的随机数作为线程的ID。
*
* 释放锁:为了保证线程获取的锁，于释放的锁是同一个，在删除reids的key的时候，要对线程ID进行判断，是同一个ID才进行删除
*
* 如何防止死锁
*        1.设置一个获取锁之前的一个时间段，线程如果在这个时间段还没有获取到锁，那么线程就放弃获取锁，返回null
* 2.还要设置另一个时间段，就是线程获取到锁之后，对key设置有效时间，过了这个是时间段，key自动删除，释放锁返回线程ID
*
* @author zxlovey
*
*/
public class LockRedis {
   // jedis线程池
   private JedisPool jedisPool;

   public LockRedis(JedisPool jedisPool) {
       this.jedisPool = jedisPool;
   }

private String reidsKey = "redis_key";

   // 获取锁
   /**
   *
   * @param acquireTimeout
   * 获取锁之前的一个时间段
   * @param timeOut
   * 线程获取到锁之后，对key设置有效时间一般以秒为单位
   */
   public String getLockRedis(Long acquireTimeout, Long timeOut) {
       Jedis conn = null;
       try {
           // 获取到jedis
           conn = jedisPool.getResource();

Long endTime = System.currentTimeMillis() + acquireTimeout;
int expireLock = (int) (timeOut / 1000);

String identifierValue = UUID.randomUUID().toString();

           while (System.currentTimeMillis() < endTime) {
               if (conn.setnx(reidsKey, identifierValue) == 1) {
                   // 获取锁设置有效时间
                   conn.expire(reidsKey, expireLock);
                   // 返回value,这个value作为线程id 释放锁的时候需要判断删除的key 和获取的锁是同一个
                   return identifierValue;
               }
           }

       } catch (Exception e) {
           // TODO: handle exception
       } finally {
           if (conn != null) {
               conn.close();
           }
       }

return null;
}

   // 释放锁
   /**
   *
   * @param identifierValue
   * 锁的ID，就是key 对应的value
   */
   public void unLockRedis(String identifierValue) {
       Jedis conn = null;
       try {
           conn = jedisPool.getResource();

           if (conn.get(reidsKey).equals(identifierValue)) {
               // 获取的key的value相同，说明是同一个线程的锁资源
               // 删除key
               conn.del(reidsKey);
               System.out.println("释放锁成功:" + Thread.currentThread().getName() + "---锁的ID:" + identifierValue);
           }

} catch (Exception e) {

       } finally {
           if (conn != null) {
               conn.close();
           }
       }
   }

}

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

public class LockServer {
private static JedisPool pool = null;

   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, "127.0.0.1", 6379, 3000);
   }

   private LockRedis lockRedis = new LockRedis(pool);

       //演示redis实现分布式锁
       public void seckill() {
           //1.获取到锁
           String identifierValue = lockRedis.getLockRedis(1000L, 1000L);
           if(identifierValue == null){
               System.out.println("获取锁失败:"+Thread.currentThread().getName()+";失败原因是获取锁的时间超时");
               return;
           }
           System.out.println("获取锁成功:"+Thread.currentThread().getName()+"---锁的ID："+identifierValue);

           //2.释放锁
           lockRedis.unLockRedis(identifierValue);
       }

}

public class ThreadLock extends Thread{
   private LockServer lockServer;

   public ThreadLock(LockServer lockServer) {
       this.lockServer = lockServer;
   }

   @Override
   public void run() {
       lockServer.seckill();
   }

}

public class Test001 {
   public static void main(String[] args) {
       LockServer lockServer = new LockServer();
       for (int i = 0; i < 500; i++) {
           ThreadLock tl = new ThreadLock(lockServer);
           tl.start();
       }
   }
}

学习redis实现分布式锁-----自己的一个理解

猜你喜欢