`

Java 实现基于Redis的分布式可重入锁

分布式锁redisjava可重入锁reentrantlock 
阅读更多

Java 实现基于Redis的分布式可重入锁

之前在 Java实现基于的Redis的分布式锁 这篇文章中，已经实现了加锁的逻辑，但是有个缺点，就是不可重入，任何重入锁的尝试都会导致死锁的发生，想了一下，这个问题可以解决。

 

 

Thinking

 

如何实现可重入？

 

首先锁信息(指redis中lockKey关联的value值) 必须得设计的能负载更多信息，之前non-reentrant时value直接就是一个超时时间，但是要实现可重入单超时时间是不够的，必须要标识锁是被谁持有的，也就是说要标识分布式环境中的线程，还要记录锁被入了多少次。

 

 

如何在分布式线程中标识唯一线程？

 

MAC地址 + jvm进程ID + 线程ID（或者线程地址都行）,三者结合即可唯一分布式环境中的线程。

 

 

实现

 

锁的信息采用json存储，格式如下：

 

 

 

 代码框架还是和之前实现的非重入的差不多，重点是lock方法，代码已有非常详细的注释

 

Java代码 
  1. package cc.lixiaohui.lock.redis;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.SocketAddress;  
  5. import java.util.concurrent.TimeUnit;  
  6.   
  7. import org.slf4j.Logger;  
  8. import org.slf4j.LoggerFactory;  
  9.   
  10. import redis.clients.jedis.Jedis;  
  11. import cc.lixiaohui.lock.AbstractLock;  
  12. import cc.lixiaohui.lock.Lock;  
  13. import cc.lixiaohui.lock.time.nio.client.TimeClient;  
  14. import cc.lixiaohui.lock.util.LockInfo;  
  15.   
  16. /** 
  17.  * 基于Redis的SETNX操作实现的分布式锁, 获取锁时最好用tryLock(long time, TimeUnit unit), 以免网路问题而导致线程一直阻塞. 
  18.  * <a href="http://redis.io/commands/setnx">SETNC操作参考资料.</a> 
  19.  *  
  20.  * <p><b>可重入实现关键:</b> 
  21.  * <ul> 
  22.  * <li>在分布式环境中如何确定一个线程? <i><b>mac地址 + jvm pid + threadId</b></i> (mac地址唯一, jvm 
  23.  * pid在单机内唯一, threadId在单jvm内唯一)</li> 
  24.  * <li>任何一个线程从redis拿到value值后都需要能确定 该锁是否被自己持有, 因此value值要有以下特性: 保存持有锁的主机(mac), jvm 
  25.  * pid, 持有锁的线程ID, 重复持有锁的次数</li> 
  26.  * </ul></p> 
  27.  * <p> 
  28.  * redis中value设计如下(in json): 
  29.  * <pre> 
  30.  * { 
  31.  *  expires : expire time in long 
  32.  *  mac : mac address of lock holder's machine 
  33.  *  pid : jvm process id 
  34.  *  threadId : lock holder thread id 
  35.  *  count : hold count(for use of reentrancy) 
  36.  * } 
  37.  * 由{@link LockInfo LockInfo}表示. 
  38.  * </pre> 
  39.  *  
  40.  * <b>Usage Example:</b> 
  41.  * <pre> 
  42.  *  {@link Lock} lock = new {@link ReentrantLock}(jedis, "lockKey", lockExpires, timeServerAddr); 
  43.  *  if (lock.tryLock(3, TimeUnit.SECONDS)) { 
  44.  *      try { 
  45.  *          // do something 
  46.  *      } catch (Exception e) { 
  47.  *          lock.unlock(); 
  48.  *      } 
  49.  *  } 
  50.  * </pre> 
  51.  * </p> 
  52.  *  
  53.  * @author lixiaohui 
  54.  * @date 2016年9月15日 下午2:52:38 
  55.  * 
  56.  */  
  57. public class ReentrantLock extends AbstractLock {  
  58.   
  59.     private Jedis jedis;  
  60.   
  61.     private TimeClient timeClient;  
  62.   
  63.     // 锁的名字  
  64.     protected String lockKey;  
  65.   
  66.     // 锁的有效时长(毫秒)  
  67.     protected long lockExpires;  
  68.   
  69.     private static final Logger logger = LoggerFactory.getLogger(ReentrantLock.class);  
  70.   
  71.     public ReentrantLock(Jedis jedis, String lockKey, long lockExpires, SocketAddress timeServerAddr) throws IOException {  
  72.         this.jedis = jedis;  
  73.         this.lockKey = lockKey;  
  74.         this.lockExpires = lockExpires;  
  75.         timeClient = new TimeClient(timeServerAddr);  
  76.     }  
  77.   
  78.     // 阻塞式获取锁的实现  
  79.     protected boolean lock(boolean useTimeout, long time, TimeUnit unit, boolean interrupt) throws InterruptedException {  
  80.         if (interrupt) {  
  81.             checkInterruption();  
  82.         }  
  83.   
  84.         // 超时控制 的时间可以从本地获取, 因为这个和锁超时没有关系, 只是一段时间区间的控制  
  85.         long start = localTimeMillis();  
  86.         long timeout = unit.toMillis(time); // if !useTimeout, then it's useless  
  87.   
  88.         // walkthrough  
  89.         // 1. lockKey未关联value, 直接设置lockKey, 成功获取到锁, return true  
  90.         // 2. lock 已过期, 用getset设置lockKey, 判断返回的旧的LockInfo  
  91.         // 2.1 若仍是超时的, 则成功获取到锁, return true  
  92.         // 2.2 若不是超时的, 则进入下一次循环重新开始 步骤1  
  93.         // 3. lock没过期, 判断是否是当前线程持有  
  94.         // 3.1 是, 则计数加 1, return true  
  95.         // 3.2 否, 则进入下一次循环重新开始 步骤1  
  96.         // note: 每次进入循环都检查 : 1.是否超时, 若是则return false; 2.是否检查中断(interrupt)被中断,  
  97.         // 若需检查中断且被中断, 则抛InterruptedException  
  98.         while (useTimeout ? !isTimeout(start, timeout) : true) {  
  99.             if (interrupt) {  
  100.                 checkInterruption();  
  101.             }  
  102.   
  103.             long lockExpireTime = serverTimeMillis() + lockExpires + 1;// 锁超时时间  
  104.             String newLockInfoJson = LockInfo.newForCurrThread(lockExpireTime).toString();  
  105.             if (jedis.setnx(lockKey, newLockInfoJson) == 1) { // 条件能成立的唯一情况就是redis中lockKey还未关联value  
  106.                 // TODO 成功获取到锁, 设置相关标识  
  107.                 logger.debug("{} get lock(new), lockInfo: {}", Thread.currentThread().getName(), newLockInfoJson);  
  108.                 locked = true;  
  109.                 return true;  
  110.             }  
  111.   
  112.             // value已有值, 但不能说明锁被持有, 因为锁可能expired了  
  113.             String currLockInfoJson = jedis.get(lockKey);  
  114.             // 若这瞬间锁被delete了  
  115.             if (currLockInfoJson == null) {  
  116.                 continue;  
  117.             }  
  118.   
  119.             LockInfo currLockInfo = LockInfo.fromString(currLockInfoJson);  
  120.             // 竞争条件只可能出现在锁超时的情况, 因为如果没有超时, 线程发现锁并不是被自己持有, 线程就不会去动value  
  121.             if (isTimeExpired(currLockInfo.getExpires())) {  
  122.                 // 锁超时了  
  123.                 LockInfo oldLockInfo = LockInfo.fromString(jedis.getSet(lockKey, newLockInfoJson));  
  124.                 if (oldLockInfo != null && isTimeExpired(oldLockInfo.getExpires())) {  
  125.                     // TODO 成功获取到锁, 设置相关标识  
  126.                     logger.debug("{} get lock(new), lockInfo: {}", Thread.currentThread().getName(), newLockInfoJson);  
  127.                     locked = true;  
  128.                     return true;  
  129.                 }  
  130.             } else {  
  131.                 // 锁未超时, 不会有竞争情况  
  132.                 if (isHeldByCurrentThread(currLockInfo)) { // 当前线程持有  
  133.                     // TODO 成功获取到锁, 设置相关标识  
  134.                     currLockInfo.setExpires(serverTimeMillis() + lockExpires + 1); // 设置新的锁超时时间  
  135.                     currLockInfo.incCount();  
  136.                     jedis.set(lockKey, currLockInfo.toString());  
  137.                     logger.debug("{} get lock(inc), lockInfo: {}", Thread.currentThread().getName(), currLockInfo);  
  138.                     locked = true;  
  139.                     return true;  
  140.                 }  
  141.             }  
  142.         }  
  143.         locked = false;  
  144.         return false;  
  145.     }  
  146.   
  147.     public boolean tryLock() {  
  148.         long lockExpireTime = serverTimeMillis() + lockExpires + 1;  
  149.         String newLockInfo = LockInfo.newForCurrThread(lockExpireTime).toString();  
  150.   
  151.         if (jedis.setnx(lockKey, newLockInfo) == 1) {  
  152.             locked = true;  
  153.             return true;  
  154.         }  
  155.   
  156.         String currLockInfoJson = jedis.get(lockKey);  
  157.         if (currLockInfoJson == null) {  
  158.             // 再一次尝试获取  
  159.             if (jedis.setnx(lockKey, newLockInfo) == 1) {  
  160.                 locked = true;  
  161.                 return true;  
  162.             } else {  
  163.                 locked = false;  
  164.                 return false;  
  165.             }  
  166.         }  
  167.           
  168.         LockInfo currLockInfo = LockInfo.fromString(currLockInfoJson);  
  169.           
  170.         if (isTimeExpired(currLockInfo.getExpires())) {  
  171.             LockInfo oldLockInfo = LockInfo.fromString(jedis.getSet(lockKey, newLockInfo));  
  172.             if (oldLockInfo != null && isTimeExpired(oldLockInfo.getExpires())) {  
  173.                 locked = true;  
  174.                 return true;  
  175.             }  
  176.         } else {  
  177.             if (isHeldByCurrentThread(currLockInfo)) {  
  178.                 currLockInfo.setExpires(serverTimeMillis() + lockExpires + 1);   
  179.                 currLockInfo.incCount();  
  180.                 jedis.set(lockKey, currLockInfo.toString());  
  181.                 locked = true;  
  182.                 return true;  
  183.             }  
  184.         }  
  185.         locked = false;  
  186.         return false;  
  187.     }  
  188.   
  189.     /** 
  190.      * Queries if this lock is held by any thread. 
  191.      *  
  192.      * @return {@code true} if any thread holds this lock and {@code false} 
  193.      *         otherwise 
  194.      */  
  195.     public boolean isLocked() {  
  196.         // walkthrough  
  197.         // 1. lockKey未关联value, return false  
  198.         // 2. 若 lock 已过期, return false, 否则 return true  
  199.         if (!locked) { // 本地locked为false, 肯定没加锁  
  200.             return false;  
  201.         }  
  202.         String json = jedis.get(lockKey);  
  203.         if (json == null) {  
  204.             return false;  
  205.         }  
  206.         if (isTimeExpired(LockInfo.fromString(json).getExpires())) {  
  207.             return false;  
  208.         }  
  209.         return true;  
  210.     }  
  211.   
  212.     @Override  
  213.     protected void unlock0() {  
  214.         // walkthrough  
  215.         // 1. 若锁过期, return  
  216.         // 2. 判断自己是否是锁的owner  
  217.         // 2.1 是, 若 count = 1, 则删除lockKey; 若 count > 1, 则计数减 1, return  
  218.         // 2.2 否, 则抛异常 IllegalMonitorStateException, reutrn  
  219.         // done, return  
  220.         LockInfo currLockInfo = LockInfo.fromString(jedis.get(lockKey));  
  221.         if (isTimeExpired(currLockInfo.getExpires())) {  
  222.             return;  
  223.         }  
  224.   
  225.         if (isHeldByCurrentThread(currLockInfo)) {  
  226.             if (currLockInfo.getCount() == 1) {  
  227.                 jedis.del(lockKey);  
  228.                 logger.debug("{} unlock(del), lockInfo: null", Thread.currentThread().getName());  
  229.             } else {  
  230.                 currLockInfo.decCount(); // 持有锁计数减1  
  231.                 String json = currLockInfo.toString();  
  232.                 jedis.set(lockKey, json);  
  233.                 logger.debug("{} unlock(dec), lockInfo: {}", Thread.currentThread().getName(), json);  
  234.             }  
  235.         } else {  
  236.             throw new IllegalMonitorStateException(String.format("current thread[%s] does not holds the lock", Thread.currentThread().toString()));  
  237.         }  
  238.   
  239.     }  
  240.   
  241.     public void release() {  
  242.         jedis.close();  
  243.         timeClient.close();  
  244.     }  
  245.       
  246.     public boolean isHeldByCurrentThread() {  
  247.         return isHeldByCurrentThread(LockInfo.fromString(jedis.get(lockKey)));  
  248.     }  
  249.   
  250.     // ------------------- utility methods ------------------------  
  251.   
  252.     private boolean isHeldByCurrentThread(LockInfo lockInfo) {  
  253.         return lockInfo.isCurrentThread();  
  254.     }  
  255.   
  256.     private void checkInterruption() throws InterruptedException {  
  257.         if (Thread.currentThread().isInterrupted()) {  
  258.             throw new InterruptedException();  
  259.         }  
  260.     }  
  261.   
  262.     private boolean isTimeExpired(long time) {  
  263.         return time < serverTimeMillis();  
  264.     }  
  265.   
  266.     private boolean isTimeout(long start, long timeout) {  
  267.         // 这里拿本地的时间来比较  
  268.         return start + timeout < System.currentTimeMillis();  
  269.     }  
  270.   
  271.     private long serverTimeMillis() {  
  272.         return timeClient.currentTimeMillis();  
  273.     }  
  274.   
  275.     private long localTimeMillis() {  
  276.         return System.currentTimeMillis();  
  277.     }  
  278.   
  279. }  

 

 测试

 

5个线程，每个线程都是不同的jedis连接，模拟分布式环境，线程的任务就是不断的去尝试重入地获取锁，重入的次数为随机但在0-5之间。

 

代码

 

Java代码 
  1. package cc.lixiaohui.DistributedLock.DistributedLock;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.InetSocketAddress;  
  5. import java.net.SocketAddress;  
  6. import java.util.ArrayList;  
  7. import java.util.List;  
  8. import java.util.Random;  
  9. import java.util.concurrent.TimeUnit;  
  10.   
  11. import org.junit.Test;  
  12.   
  13. import redis.clients.jedis.Jedis;  
  14. import cc.lixiaohui.lock.redis.ReentrantLock;  
  15.   
  16. /** 
  17.  * @author lixiaohui 
  18.  * @date 2016年9月28日 下午8:41:36 
  19.  *  
  20.  */  
  21. public class ReentrantTest {  
  22.       
  23.     final int EXPIRES = 10 * 1000;  
  24.       
  25.     final String LOCK_KEY = "lock.lock";  
  26.       
  27.     final SocketAddress TIME_SERVER_ADDR = new InetSocketAddress("localhost", 9999);  
  28.       
  29.     @Test  
  30.     public void test() throws Exception {  
  31.         // 创建5个线程不停地去重入(随机次数n, 0 <= n <=5)获取锁  
  32.         List<Thread> threads = createThreads(5);  
  33.         //开始任务  
  34.         for (Thread t : threads) {  
  35.             t.start();  
  36.         }  
  37.         // 执行60秒  
  38.         Thread.sleep(60 * 1000);  
  39.         //停止所有线程  
  40.         Task.alive = false;  
  41.         // 等待所有线程终止  
  42.         for (Thread t : threads) {  
  43.             t.join();  
  44.         }  
  45.           
  46.     }  
  47.     // 创建count个线程，每个线程都是不同的jedis连接以及不同的与时间服务器的连接  
  48.     private List<Thread> createThreads(int count) throws IOException {  
  49.         List<Thread> threads = new ArrayList<Thread>();  
  50.         for (int i = 0; i < count; i++) {  
  51.             Jedis jedis = new Jedis("localhost", 6379);  
  52.             ReentrantLock lock = new ReentrantLock(jedis, LOCK_KEY, EXPIRES, TIME_SERVER_ADDR);  
  53.             Task task = new Task(lock);  
  54.             Thread t = new Thread(task);  
  55.             threads.add(t);  
  56.         }  
  57.         return threads;  
  58.     }  
  59.       
  60.     private static class Task implements Runnable {  
  61.           
  62.         private ReentrantLock lock;  
  63.           
  64.         private final int MAX_ENTRANT = 5;  
  65.           
  66.         private final Random random = new Random();  
  67.           
  68.         private static boolean alive = true;  
  69.           
  70.         Task(ReentrantLock lock) {  
  71.             this.lock = lock;  
  72.         }  
  73.           
  74.         public void run() {  
  75.             while (alive) {  
  76.                 int times = random.nextInt(MAX_ENTRANT);  
  77.                 doLock(times);  
  78.             }  
  79.         }  
  80.           
  81.         private void doLock(int times) {  
  82.             if (lock.tryLock(5, TimeUnit.SECONDS)) {  
  83.                 try {  
  84.                     if (times > 0) {  
  85.                         doLock(--times);  
  86.                     }  
  87.                 } finally {  
  88.                     if (lock != null) {  
  89.                         lock.unlock();  
  90.                     }  
  91.                 }  
  92.             }  
  93.               
  94.         }  
  95.           
  96.           
  97.           
  98.     }  
  99.       
  100. }  

 

测试结果

 

下面是一部分日志输出：

Java代码 
  1. 21:09:22.328-[DEBUG] Thread-0 ReentrantLock - Thread-0 get lock(new), lockInfo: {"count":1,"expires":1475068172329,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  2. 21:09:22.330-[DEBUG] Thread-0 ReentrantLock - Thread-0 get lock(inc), lockInfo: {"count":2,"expires":1475068172330,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  3. 21:09:22.331-[DEBUG] Thread-0 ReentrantLock - Thread-0 get lock(inc), lockInfo: {"count":3,"expires":1475068172332,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  4. 21:09:22.332-[DEBUG] Thread-0 ReentrantLock - Thread-0 get lock(inc), lockInfo: {"count":4,"expires":1475068172333,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  5. 21:09:22.334-[DEBUG] Thread-0 ReentrantLock - Thread-0 get lock(inc), lockInfo: {"count":5,"expires":1475068172334,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  6. 21:09:22.335-[DEBUG] Thread-0 ReentrantLock - Thread-0 unlock(dec), lockInfo: {"count":4,"expires":1475068172334,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  7. 21:09:22.336-[DEBUG] Thread-0 ReentrantLock - Thread-0 unlock(dec), lockInfo: {"count":3,"expires":1475068172334,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  8. 21:09:22.338-[DEBUG] Thread-0 ReentrantLock - Thread-0 unlock(dec), lockInfo: {"count":2,"expires":1475068172334,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  9. 21:09:22.339-[DEBUG] Thread-0 ReentrantLock - Thread-0 unlock(dec), lockInfo: {"count":1,"expires":1475068172334,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  10. 21:09:22.340-[DEBUG] Thread-0 ReentrantLock - Thread-0 unlock(del), lockInfo: null  
  11. 21:09:22.341-[DEBUG] Thread-0 ReentrantLock - Thread-0 get lock(new), lockInfo: {"count":1,"expires":1475068172341,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  12. 21:09:22.341-[DEBUG] Thread-0 ReentrantLock - Thread-0 unlock(del), lockInfo: null  
  13. 21:09:22.342-[DEBUG] Thread-0 ReentrantLock - Thread-0 get lock(new), lockInfo: {"count":1,"expires":1475068172342,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  14. 21:09:22.343-[DEBUG] Thread-0 ReentrantLock - Thread-0 get lock(inc), lockInfo: {"count":2,"expires":1475068172344,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  15. 21:09:22.344-[DEBUG] Thread-0 ReentrantLock - Thread-0 unlock(dec), lockInfo: {"count":1,"expires":1475068172344,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  16. 21:09:22.345-[DEBUG] Thread-0 ReentrantLock - Thread-0 unlock(del), lockInfo: null  
  17. 21:09:22.345-[DEBUG] Thread-3 ReentrantLock - Thread-3 get lock(new), lockInfo: {"count":1,"expires":1475068172345,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":14}  
  18. 21:09:22.346-[DEBUG] Thread-3 ReentrantLock - Thread-3 get lock(inc), lockInfo: {"count":2,"expires":1475068172347,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":14}  
  19. 21:09:22.347-[DEBUG] Thread-3 ReentrantLock - Thread-3 get lock(inc), lockInfo: {"count":3,"expires":1475068172348,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":14}  
  20. 21:09:22.349-[DEBUG] Thread-3 ReentrantLock - Thread-3 get lock(inc), lockInfo: {"count":4,"expires":1475068172350,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":14}  
  21. 21:09:22.350-[DEBUG] Thread-3 ReentrantLock - Thread-3 unlock(dec), lockInfo: {"count":3,"expires":1475068172350,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":14}  
  22. 21:09:22.350-[DEBUG] Thread-3 ReentrantLock - Thread-3 unlock(dec), lockInfo: {"count":2,"expires":1475068172350,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":14}  
  23. 21:09:22.351-[DEBUG] Thread-3 ReentrantLock - Thread-3 unlock(dec), lockInfo: {"count":1,"expires":1475068172350,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":14}  
  24. 21:09:22.351-[DEBUG] Thread-3 ReentrantLock - Thread-3 unlock(del), lockInfo: null  
  25. 21:09:22.352-[DEBUG] Thread-3 ReentrantLock - Thread-3 get lock(new), lockInfo: {"count":1,"expires":1475068172352,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":14}  
  26. 21:09:22.352-[DEBUG] Thread-3 ReentrantLock - Thread-3 unlock(del), lockInfo: null  
  27. 21:09:22.352-[DEBUG] Thread-0 ReentrantLock - Thread-0 get lock(new), lockInfo: {"count":1,"expires":1475068172353,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  28. 21:09:22.354-[DEBUG] Thread-0 ReentrantLock - Thread-0 get lock(inc), lockInfo: {"count":2,"expires":1475068172355,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  29. 21:09:22.354-[DEBUG] Thread-0 ReentrantLock - Thread-0 unlock(dec), lockInfo: {"count":1,"expires":1475068172355,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  30. 21:09:22.355-[DEBUG] Thread-0 ReentrantLock - Thread-0 unlock(del), lockInfo: null  
  31. 21:09:22.355-[DEBUG] Thread-4 ReentrantLock - Thread-4 get lock(new), lockInfo: {"count":1,"expires":1475068172356,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":15}  
  32. 21:09:22.357-[DEBUG] Thread-4 ReentrantLock - Thread-4 get lock(inc), lockInfo: {"count":2,"expires":1475068172357,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":15}  
  33. 21:09:22.358-[DEBUG] Thread-4 ReentrantLock - Thread-4 get lock(inc), lockInfo: {"count":3,"expires":1475068172358,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":15}  
  34. 21:09:22.359-[DEBUG] Thread-4 ReentrantLock - Thread-4 get lock(inc), lockInfo: {"count":4,"expires":1475068172360,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":15}  
  35. 21:09:22.360-[DEBUG] Thread-4 ReentrantLock - Thread-4 unlock(dec), lockInfo: {"count":3,"expires":1475068172360,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":15}  
  36. 21:09:22.361-[DEBUG] Thread-4 ReentrantLock - Thread-4 unlock(dec), lockInfo: {"count":2,"expires":1475068172360,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":15}  
  37. 21:09:22.361-[DEBUG] Thread-4 ReentrantLock - Thread-4 unlock(dec), lockInfo: {"count":1,"expires":1475068172360,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":15}  
  38. 21:09:22.362-[DEBUG] Thread-4 ReentrantLock - Thread-4 unlock(del), lockInfo: null  
  39. 21:09:22.362-[DEBUG] Thread-0 ReentrantLock - Thread-0 get lock(new), lockInfo: {"count":1,"expires":1475068172363,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  40. 21:09:22.363-[DEBUG] Thread-0 ReentrantLock - Thread-0 get lock(inc), lockInfo: {"count":2,"expires":1475068172364,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  41. 21:09:22.365-[DEBUG] Thread-0 ReentrantLock - Thread-0 get lock(inc), lockInfo: {"count":3,"expires":1475068172365,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  42. 21:09:22.365-[DEBUG] Thread-0 ReentrantLock - Thread-0 unlock(dec), lockInfo: {"count":2,"expires":1475068172365,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  43. 21:09:22.366-[DEBUG] Thread-0 ReentrantLock - Thread-0 unlock(dec), lockInfo: {"count":1,"expires":1475068172365,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":11}  
  44. 21:09:22.367-[DEBUG] Thread-0 ReentrantLock - Thread-0 unlock(del), lockInfo: null  
  45. 21:09:22.367-[DEBUG] Thread-4 ReentrantLock - Thread-4 get lock(new), lockInfo: {"count":1,"expires":1475068172368,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":15}  
  46. 21:09:22.368-[DEBUG] Thread-4 ReentrantLock - Thread-4 get lock(inc), lockInfo: {"count":2,"expires":1475068172369,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":15}  
  47. 21:09:22.370-[DEBUG] Thread-4 ReentrantLock - Thread-4 unlock(dec), lockInfo: {"count":1,"expires":1475068172369,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":15}  
  48. 21:09:22.372-[DEBUG] Thread-4 ReentrantLock - Thread-4 unlock(del), lockInfo: null  
  49. 21:09:22.372-[DEBUG] Thread-1 ReentrantLock - Thread-1 get lock(new), lockInfo: {"count":1,"expires":1475068172373,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":12}  
  50. 21:09:22.374-[DEBUG] Thread-1 ReentrantLock - Thread-1 get lock(inc), lockInfo: {"count":2,"expires":1475068172374,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":12}  
  51. 21:09:22.375-[DEBUG] Thread-1 ReentrantLock - Thread-1 get lock(inc), lockInfo: {"count":3,"expires":1475068172376,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":12}  
  52. 21:09:22.376-[DEBUG] Thread-1 ReentrantLock - Thread-1 get lock(inc), lockInfo: {"count":4,"expires":1475068172376,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":12}  
  53. 21:09:22.376-[DEBUG] Thread-1 ReentrantLock - Thread-1 get lock(inc), lockInfo: {"count":5,"expires":1475068172377,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":12}  
  54. 21:09:22.377-[DEBUG] Thread-1 ReentrantLock - Thread-1 unlock(dec), lockInfo: {"count":4,"expires":1475068172377,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":12}  
  55. 21:09:22.377-[DEBUG] Thread-1 ReentrantLock - Thread-1 unlock(dec), lockInfo: {"count":3,"expires":1475068172377,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":12}  
  56. 21:09:22.378-[DEBUG] Thread-1 ReentrantLock - Thread-1 unlock(dec), lockInfo: {"count":2,"expires":1475068172377,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":12}  
  57. 21:09:22.378-[DEBUG] Thread-1 ReentrantLock - Thread-1 unlock(dec), lockInfo: {"count":1,"expires":1475068172377,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":12}  
  58. 21:09:22.379-[DEBUG] Thread-1 ReentrantLock - Thread-1 unlock(del), lockInfo: null  
  59. 21:09:22.379-[DEBUG] Thread-2 ReentrantLock - Thread-2 get lock(new), lockInfo: {"count":1,"expires":1475068172380,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":13}  
  60. 21:09:22.380-[DEBUG] Thread-2 ReentrantLock - Thread-2 get lock(inc), lockInfo: {"count":2,"expires":1475068172380,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":13}  
  61. 21:09:22.380-[DEBUG] Thread-2 ReentrantLock - Thread-2 unlock(dec), lockInfo: {"count":1,"expires":1475068172380,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":13}  
  62. 21:09:22.380-[DEBUG] Thread-2 ReentrantLock - Thread-2 unlock(del), lockInfo: null  
  63. 21:09:22.380-[DEBUG] Thread-3 ReentrantLock - Thread-3 get lock(new), lockInfo: {"count":1,"expires":1475068172381,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":14}  
  64. 21:09:22.381-[DEBUG] Thread-3 ReentrantLock - Thread-3 get lock(inc), lockInfo: {"count":2,"expires":1475068172382,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":14}  
  65. 21:09:22.381-[DEBUG] Thread-3 ReentrantLock - Thread-3 get lock(inc), lockInfo: {"count":3,"expires":1475068172382,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":14}  
  66. 21:09:22.382-[DEBUG] Thread-3 ReentrantLock - Thread-3 unlock(dec), lockInfo: {"count":2,"expires":1475068172382,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":14}  
  67. 21:09:22.382-[DEBUG] Thread-3 ReentrantLock - Thread-3 unlock(dec), lockInfo: {"count":1,"expires":1475068172382,"jvmPid":22224,"mac":"28-D2-44-0E-0D-9A","threadId":14}  
  68. 21:09:22.382-[DEBUG] Thread-3 ReentrantLock - Thread-3 unlock(del), lockInfo: null  

 看日志输出，lockInfo对应的json就是redis中lockKey对应的值，可以看到这个重入锁正常工作(count先递增后递减，在count不为0时别的线程拿不到锁)。测试通过，性能上还待改善

 

 

Thinking again

 

如何实现读写锁？

 

目前想出的一种实现是redis中存两个键值对，一个读一个写，随之而来的一个问题是：对于加锁过程，可能会要求对这两个键值的更改（这里指一起更改两者）要具有原子性，因此得用一个额外的重入锁，来同步这个操作。但这样实现未免代价太大，仍思考解决方法中..........路过的大神请指条明路...

 

 代码放这里了：戳我

2
顶
1
踩
分享到：
| Java 获取当前JVM进程ID
评论
2 楼 莫名的拉风 2016-11-26  
AiJava* 写道
超时与unlock哪儿应该有点问题,如果上次持有锁有线程超时但还没有释放锁，
此时锁可以被另一个线程抢占，但上次持有锁有线程再释放时，
if (Thread.currentThread() != getExclusiveOwnerThread()) {
             // 如果超时了,但自己还没有unlock，此时已被其它线程抢占了锁
            throw new IllegalMonitorStateException("current thread does not hold the lock"+Thread.currentThread().getId());
        }
这儿就抛异常了吧


是的，之前已经把Thread exclusiveOwnerThread这个字段去掉了，在多进程环境中这个字段根本就没啥用，实现重入时就考虑到把当前持有锁线程的标识存到了redis上，忘了更新博客
1 楼 AiJava* 2016-11-24  
超时与unlock哪儿应该有点问题,如果上次持有锁有线程超时但还没有释放锁，
此时锁可以被另一个线程抢占，但上次持有锁有线程再释放时，
if (Thread.currentThread() != getExclusiveOwnerThread()) {
             // 如果超时了,但自己还没有unlock，此时已被其它线程抢占了锁
            throw new IllegalMonitorStateException("current thread does not hold the lock"+Thread.currentThread().getId());
        }
这儿就抛异常了吧
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java基于redis实现分布式锁代码实例

    Java基于Redis实现分布式锁代码实例 分布式锁的必要性 在多线程环境中，资源竞争是一个常见的问题。例如，在一个简单的用户操作中，一个线程修改用户状态，首先在内存中读取用户状态，然后在内存中进行修改，然后...

    java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统.zip

    Java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统。一个基于Spring Boot + WebSocket + Redis，可快速开发的分布式即时通讯群聊系统。适用于直播间聊天、游戏内聊天、客服聊天等临时性群聊场景。 ...

    redislock-基于redis的分布式可重入锁

    本文将深入探讨基于Redis的分布式可重入锁及其在Java开发中的应用。 首先，我们需要理解“可重入锁”的概念。可重入锁允许一个线程多次获取同一锁，这是为了防止死锁的发生。在Java中，ReentrantLock是内置的可重入...

    springboot基于redis分布式锁

    本教程将深入探讨如何在SpringBoot应用中实现基于Redis的分布式锁。 首先，Redis之所以常被用作分布式锁的实现，是因为其具有以下优点： 1. **高可用性**：Redis支持主从复制，可以确保在单点故障时仍有服务可用。...

    记录redisson实现redis分布式事务锁

    Redisson是基于Redis的Java客户端，它提供了丰富的数据结构和服务，包括分布式锁、信号量、队列、计数器等，极大地扩展了Redis在分布式系统中的应用能力。本篇文章将详细探讨如何使用Redisson实现Redis分布式事务锁...

    基于Redis方式实现分布式锁

    以下是一个简单的Java示例，展示了如何使用Jedis客户端库来实现Redis分布式锁。 ```java public class RedisLock { private JedisPool jedisPool; public RedisLock(JedisPool jedisPool) { this.jedisPool = ...

    redis实现分布式锁,自旋式加锁,lua原子性解锁

    Redis中的分布式锁实现通常基于`SETNX`命令或`SET`命令的`nx`与`ex`组合。`SETNX`命令用于设置键值，但如果键已经存在，则不执行任何操作，这可以确保锁的互斥性。`SET key value EX timeout NX`则同时设置了超时...

    Java Redis分布式锁的正确实现方式详解

    Java Redis分布式锁的正确实现方式详解 Java Redis分布式锁是指使用Redis实现的分布式锁机制，旨在解决分布式系统中的并发问题。分布式锁有三种实现方式：数据库乐观锁、基于Redis的分布式锁和基于ZooKeeper的...

    redis分布式锁工具包，提供纯Java方式调用，支持传统Spring工程.zip

    综上所述，这个压缩包提供的Redis分布式锁工具包为Java开发者提供了一种简单、高效的方法来解决分布式环境下的锁问题，特别适合于处理高并发的快应用和企业级应用。通过集成到Spring工程中，开发人员可以利用Redis的...

    基于 Redis 的分布式锁

    在实现基于Redis的分布式锁时，通常会用到两个命令：NX（Not eXists）和EX（过期时间）。NX命令确保只有在键不存在时才能被设置，这样可以保证锁的互斥性。EX命令则是用来设置键的过期时间，保证锁可以在一段时间后...

    003 redis分布式锁 jedis分布式锁 Redisson分布式锁 分段锁

    Redisson的分布式锁实现更加完善，支持可重入锁、公平锁、读写锁，还具有锁自动续期功能，避免了因网络延迟导致的锁丢失。使用Redisson创建分布式锁只需几行代码，通过`RLock`接口的`lock()`和`unlock()`方法即可...

    Java基于Redis分布式消息队的报文过滤系统的设计与实现

    ### Java基于Redis分布式消息队的报文过滤系统的设计与实现 #### 一、课题背景与研究意义 随着民用航空业的快速发展，特别是近年来各地新建或扩建民用机场的趋势，导致航空报文数量急剧增加。传统的报文处理系统...

    redis和redisson实现分布式锁

    Redis作为一款高性能的键值存储系统，常被用作实现分布式锁的工具，而Redisson是基于Redis的Java客户端，提供了丰富的数据结构和服务功能，包括对分布式锁的支持。本文将深入探讨如何使用Redis和Redisson来构建...

    基于redis分布式锁实现“秒杀”

    ### 基于Redis分布式锁实现“秒杀” #### 一、引言 在现代互联网应用中，“秒杀”作为一种常见的促销手段，被广泛应用于电商领域。为了保证系统的稳定性和公平性，在高并发环境下实现秒杀功能时，合理地利用分布式...

    redisTemplate封装成redisUtils和分布式锁实现

    接下来，我们将实现基于Redis的分布式锁。分布式锁的主要目的是在多节点环境下确保同一时刻只有一个节点可以执行特定操作。以下是一个简单的分布式锁实现： ```java public class DistributedLock { private ...

    基于redis的java分布式代理锁

    分布式代理锁，动态的锁后缀采用ThreadLocal或者参数名获取 锁粒度自定义选择，目前实现基于redis，后续扩展zk等 SpringBoot，默认使用redisson链接redis，可以更改注解参数使用Spring redis工具 key分为：无后缀、...

    java基于jedisLock—redis分布式锁实现示例代码

    "java基于jedisLock—redis分布式锁实现示例代码" java基于jedisLock—redis分布式锁实现示例代码主要介绍了jedisLock—redis分布式锁实现示例代码，以下是对标题和描述中所说的知识点的详细说明： 分布式锁是啥？...

    基于redis的可重入分布式锁、离线条形码生成与校验方案、常见框架使用demo.zip

    本压缩包文件“基于redis的可重入分布式锁、离线条形码生成与校验方案、常见框架使用demo.zip”提供了一系列实用的技术方案，主要涵盖三个方面：Redis实现的可重入分布式锁、离线条形码的生成与校验，以及常见框架的...

    基于redis的分布式方法锁

    在Java开发中，我们可以利用Redis作为分布式锁的实现方式，其高效、轻量级且具备良好的可扩展性。本文将深入探讨如何基于Redis实现分布式方法锁，并分析其工作原理、优势以及应用场景。 **1. Redis分布式锁的概念**...

    基于redis的分布式锁实现

    - **可重入性**：若需要支持锁的可重入性，可以在客户端维护一个计数器，并在每次获取锁时递增，解锁时递减。 - **公平性**：Redis本身并不支持公平锁，但可以通过客户端策略（如队列等待机制）来模拟实现。 ##### ...

Magicbox
Global site tag (gtag.js) - Google Analytics