我们聊一聊可重入锁特别重要的话题

本文转载自微信公众号「三太子敖丙」，作者三太子敖丙 。转载本文请联系三太子敖丙公众号。

创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都网站制作、成都网站建设、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的黄岩网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

使用Java进行多线程开发，使用锁是一个几乎不可避免的问题。今天，就让我们来聊一聊这个基础，但是又特别特别重要的话题。

首先，让我们来看一下，到底什么是锁? 以及，为什么要使用锁?

如果有2个线程，需要访问同一个对象User。一个读线程，一个写线程。User对象有2个字段，一个是名字，一个是手机号码。

 

当User对象刚刚创建出来的时候，姓名和手机号码都是空。然后，写线程开始填充数据。最后，就出现了以下令人心碎的一幕：

 

可以看到，虽然写线程先于读线程工作，但是， 由于写姓名和写电话号码两个操作不是原子的。这就导致读线程只读取了半个数据，在读线程看来，User对象的电话号码是不存在。

为了避免类似的问题，我们就需要使用锁。让写线程在修改对象前，先加锁，然后完成姓名和电话号码的赋值，再释放锁。而读线程也是一样，先取得锁，再读，然后释放锁。这样就可以避免发生这种情况。

如下图所示：

 

什么是重入锁?

好了，现在大家知道我们为什么要使用锁了。那什么是重入锁呢。通常情况下，锁可以用来控制多线程的访问行为。那对于同一个线程，如果连续两次对同一把锁进行lock，会怎么样了?对于一般的锁来说，这个线程就会被永远卡死在那边，比如：

  
 
 
 
    
   
  
  
  
  1. void handle() { 
    2. 
   
  
  
  
  2.     lock(); 
    3. 
   
  
  
  
  3.     lock();  //和上一个lock()操作同一个锁对象，那么这里就永远等待了 
    4. 
   
  
  
  
  4.     unlock(); 
    5. 
   
  
  
  
  5.     unlock(); 
    6. 
   
  
  
  
  6. } 
    7.

这个特性相当不好用，因为在实际的开发过程中，函数之间的调用关系可能错综复杂，一个不小心就可能在多个不同的函数中，反复调用lock()，这样的话，线程就自己和自己卡死了。

所以，对于希望傻瓜式编程的我们来说，重入锁就是用来解决这个问题的。重入锁使得同一个线程可以对同一把锁，在不释放的前提下，反复加锁，而不会导致线程卡死。因此，如果我们使用的是重入锁，那么上述代码就 可以正常工作。你唯一需要保证的，就是unlock()的次数和lock()一样多。这样是不是方便很多呢?

Java中的重入锁

Java中的锁都来自与Lock接口，如下图中红框内的，就是重入锁。

 

重入锁提供的最重要的方法就是lock()

  • void lock()：加锁，如果锁已经被别人占用了，就无限等待。

这个lock()方法，提供了锁最基本的功能，拿到锁就返回，拿不到就等待。因此，大规模得在复杂场景中使用，是有可能因此死锁的。因此，使用这个方法得非常小心。

如果要预防可能发生的死锁，可以尝试使用下面这个方法:

  • boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException：尝试获取锁，等待timeout时间。同时，可以响应中断。

这是一个比单纯lock()更具有工程价值的方法，如果大家阅读过JDK的一些内部代码，就不难发现，tryLock()在JDK内部被大量的使用。

与lock()相比,tryLock()至少有下面一个好处：

  1. 可以不用进行无限等待。直接打破形成死锁的条件。如果一段时间等不到锁，可以直接放弃，同时释放自己已经得到的资源。这样，就可以在很大程度上，避免死锁的产生。因为线程之间出现了一种谦让机制
  2. 可以在应用程序这层进行进行自旋，你可以自己决定尝试几次，或者是放弃。
  3. 等待锁的过程中可以响应中断，如果此时，程序正好收到关机信号，中断就会触发，进入中断异常后，线程就可以做一些清理工作，从而防止在终止程序时出现数据写坏，数据丢失等悲催的情况。

当然了，当锁使用完后，千万不要忘记把它释放了。不然，程序可能就会崩溃啦~

  • void unlock() ：释放锁

此外， 重入锁还有一个不带任何参数的tryLock()。

  • public boolean tryLock()

这个不带任何参数的tryLock()不会进行任何等待，如果能够获得锁，直接返回true，如果获取失败，就返回false，特别适合在应用层自己对锁进行管理，在应用层进行自旋等待。

重入锁的实现原理

重入锁内部实现的主要类如下图：

 

重入锁的核心功能委托给内部类Sync实现，并且根据是否是公平锁有FairSync和NonfairSync两种实现。这是一种典型的策略模式。

实现重入锁的方法很简单，就是基于一个状态变量state。这个变量保存在AbstractQueuedSynchronizer对象中

  
 
 
 
    
   
  
  
  
  1. private volatile int state; 
    2.

当这个state==0时，表示锁是空闲的，大于零表示锁已经被占用， 它的数值表示当前线程重复占用这个锁的次数。因此，lock()的最简单的实现是：

  
 
 
 
    
   
  
  
  
  1. final void lock() { 
    2. 
   
  
  
  
  2. // compareAndSetState就是对state进行CAS操作，如果修改成功就占用锁 
    3. 
   
  
  
  
  3. if (compareAndSetState(0, 1)) 
    4. 
   
  
  
  
  4.     setExclusiveOwnerThread(Thread.currentThread()); 
    5. 
   
  
  
  
  5. else 
    6. 
   
  
  
  
  6. //如果修改不成功，说明别的线程已经使用了这个锁，那么就可能需要等待 
    7. 
   
  
  
  
  7.     acquire(1); 
    8.

下面是acquire() 的实现：

  
 
 
 
    
   
  
  
  
  1. public final void acquire(int arg) { 
    2. 
   
  
  
  
  2. //tryAcquire() 再次尝试获取锁， 
    3. 
   
  
  
  
  3. //如果发现锁就是当前线程占用的，则更新state，表示重复占用的次数， 
    4. 
   
  
  
  
  4. //同时宣布获得所成功,这正是重入的关键所在 
    5. 
   
  
  
  
  5. if (!tryAcquire(arg) && 
    6. 
   
  
  
  
  6.     // 如果获取失败，那么就在这里入队等待 
    7. 
   
  
  
  
  7.     acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) 
    8. 
   
  
  
  
  8.     //如果在等待过程中 被中断了，那么重新把中断标志位设置上 
    9. 
   
  
  
  
  9.     selfInterrupt(); 
    10.

公平的重入锁

默认情况下，重入锁是不公平的。什么叫不公平呢。也就是说，如果有1,2,3,4 这四个线程，按顺序，依次请求锁。那等锁可用的时候，谁会先拿到锁呢?在非公平情况下，答案是随机的。如下图所示，可能线程3先拿到锁。

 

如果你是一个公平主义者，强烈坚持先到先得的话，那么你就需要在构造重入锁的时候，指定这是一个公平锁：

  
 
 
 
    
   
  
  
  
  1. ReentrantLock fairLock = new ReentrantLock(true); 
    2.

这样一来，每一个请求锁的线程，都会乖乖的把自己放入请求队列，而不是上来就进行争抢。但一定要注意，公平锁是有代价的。维持公平竞争是以牺牲系统性能为代价的。如果你愿意承担这个损失，公平锁至少提供了一种普世价值观的实现吧!

那公平锁和非公平锁实现的核心区别在哪里呢?来看一下这段lock()的代码：

  
 
 
 
    
   
  
  
  
  1. //非公平锁  
    2. 
   
  
  
  
  2.  final void lock() { 
    3. 
   
  
  
  
  3.      //上来不管三七二十一，直接抢了再说 
    4. 
   
  
  
  
  4.      if (compareAndSetState(0, 1)) 
    5. 
   
  
  
  
  5.          setExclusiveOwnerThread(Thread.currentThread()); 
    6. 
   
  
  
  
  6.      else 
    7. 
   
  
  
  
  7.          //抢不到，就进队列慢慢等着 
    8. 
   
  
  
  
  8.          acquire(1); 
    9. 
   
  
  
  
  9.  } 
    10. 
   
  
  
  
  10.  
    11. 
   
  
  
  
  11.  //公平锁 
    12. 
   
  
  
  
  12.  final void lock() { 
    13. 
   
  
  
  
  13.      //直接进队列等着 
    14. 
   
  
  
  
  14.      acquire(1); 
    15. 
   
  
  
  
  15.  } 
    16.

从上面的代码中也不难看到，非公平锁如果第一次争抢失败，后面的处理和公平锁是一样的，都是进入等待队列慢慢等。

对于tryLock()也是非常类似的：

  
 
 
 
    
   
  
  
  
  1. //非公平锁  
    2. 
   
  
  
  
  2. final boolean nonfairTryAcquire(int acquires) { 
    3. 
   
  
  
  
  3.      final Thread current = Thread.currentThread(); 
    4. 
   
  
  
  
  4.      int c = getState(); 
    5. 
   
  
  
  
  5.      if (c == 0) { 
    6. 
   
  
  
  
  6.          //上来不管三七二十一，直接抢了再说 
    7. 
   
  
  
  
  7.          if (compareAndSetState(0, acquires)) { 
    8. 
   
  
  
  
  8.              setExclusiveOwnerThread(current); 
    9. 
   
  
  
  
  9.              return true; 
    10. 
   
  
  
  
  10.          } 
    11. 
   
  
  
  
  11.      } 
    12. 
   
  
  
  
  12.      //如果就是当前线程占用了锁，那么就更新一下state，表示重复占用锁的次数 
    13. 
   
  
  
  
  13.      //这是“重入”的关键所在 
    14. 
   
  
  
  
  14.      else if (current == getExclusiveOwnerThread()) { 
    15. 
   
  
  
  
  15.          //我又来了哦~~~ 
    16. 
   
  
  
  
  16.          int nextc = c + acquires; 
    17. 
   
  
  
  
  17.          if (nextc < 0) // overflow 
    18. 
   
  
  
  
  18.              throw new Error("Maximum lock count exceeded"); 
    19. 
   
  
  
  
  19.          setState(nextc); 
    20. 
   
  
  
  
  20.          return true; 
    21. 
   
  
  
  
  21.      } 
    22. 
   
  
  
  
  22.      return false; 
    23. 
   
  
  
  
  23.  } 
    24. 
   
  
  
  
  24.  
    25. 
   
  
  
  
  25.  
    26. 
   
  
  
  
  26. //公平锁 
    27. 
   
  
  
  
  27. protected final boolean tryAcquire(int acquires) { 
    28. 
   
  
  
  
  28.     final Thread current = Thread.currentThread(); 
    29. 
   
  
  
  
  29.     int c = getState(); 
    30. 
   
  
  
  
  30.     if (c == 0) { 
    31. 
   
  
  
  
  31.         //先看看有没有别人在等，没有人等我才会去抢，有人在我前面 ，我就不抢啦 
    32. 
   
  
  
  
  32.         if (!hasQueuedPredecessors() && 
    33. 
   
  
  
  
  33.             compareAndSetState(0, acquires)) { 
    34. 
   
  
  
  
  34.             setExclusiveOwnerThread(current); 
    35. 
   
  
  
  
  35.             return true; 
    36. 
   
  
  
  
  36.         } 
    37. 
   
  
  
  
  37.     } 
    38. 
   
  
  
  
  38.     else if (current == getExclusiveOwnerThread()) { 
    39. 
   
  
  
  
  39.         int nextc = c + acquires; 
    40. 
   
  
  
  
  40.         if (nextc < 0) 
    41. 
   
  
  
  
  41.             throw new Error("Maximum lock count exceeded"); 
    42. 
   
  
  
  
  42.         setState(nextc); 
    43. 
   
  
  
  
  43.         return true; 
    44. 
   
  
  
  
  44.     } 
    45. 
   
  
  
  
  45.     return false; 
    46. 
   
  
  
  
  46. } 
    47.

Condition

Condition可以理解为重入锁的伴生对象。它提供了在重入锁的基础上，进行等待和通知的机制。可以使用 newCondition()方法生成一个Condition对象，如下所示。

  
 
 
 
    
   
  
  
  
  1. private final Lock lock = new ReentrantLock(); 
    2. 
   
  
  
  
  2. private final Condition condition = lock.newCondition(); 
    3.

那Condition对象怎么用呢。在JDK内部就有一个很好的例子。让我们来看一下ArrayBlockingQueue吧。ArrayBlockingQueue是一个队列，你可以把元素塞入队列(enqueue)，也可以拿出来take()。但是有一个小小的条件，就是如果队列是空的，那么take()就需要等待，一直等到有元素了，再返回。那这个功能，怎么实现呢?这就可以使用Condition对象了。

实现在ArrayBlockingQueue中，就维护一个Condition对象

  
 
 
 
    
   
  
  
  
  1. lock = new ReentrantLock(fair); 
    2. 
   
  
  
  
  2. notEmpty = lock.newCondition(); 
    3.

这个notEmpty 就是一个Condition对象。它用来通知其他线程，ArrayBlockingQueue是不是空着的。当我们需要拿出一个元素时:

  
 
 
 
    
   
  
  
  
  1. public E take() throws InterruptedException { 
    2. 
   
  
  
  
  2.     final ReentrantLock lock = this.lock; 
    3. 
   
  
  
  
  3.     lock.lockInterruptibly(); 
    4. 
   
  
  
  
  4.     try { 
    5. 
   
  
  
  
  5.         while (count == 0) 
    6. 
   
  
  
  
  6.             // 如果队列长度为0，那么就在notEmpty condition上等待了，一直等到有元素进来为止 
    7. 
   
  
  
  
  7.             // 注意，await()方法，一定是要先获得condition伴生的那个lock，才能用的哦 
    8. 
   
  
  
  
  8.             notEmpty.await(); 
    9. 
   
  
  
  
  9.         //一旦有人通知我队列里有东西了，我就弹出一个返回 
    10. 
   
  
  
  
  10.         return dequeue(); 
    11. 
   
  
  
  
  11.     } finally { 
    12. 
   
  
  
  
  12.         lock.unlock(); 
    13. 
   
  
  
  
  13.     } 
    14. 
   
  
  
  
  14. } 
    15.

当有元素入队时：

  
 
 
 
    
   
  
  
  
  1.  public boolean offer(E e) { 
    2. 
   
  
  
  
  2.     checkNotNull(e); 
    3. 
   
  
  
  
  3.     final ReentrantLock lock = this.lock; 
    4. 
   
  
  
  
  4.     //先拿到锁，拿到锁才能操作对应的Condition对象 
    5. 
   
  
  
  
  5.     lock.lock(); 
    6. 
   
  
  
  
  6.     try { 
    7. 
   
  
  
  
  7.         if (count == items.length) 
    8. 
   
  
  
  
  8.             return false; 
    9. 
   
  
  
  
  9.         else { 
    10. 
   
  
  
  
  10.             //入队了， 在这个函数里，就会进行notEmpty的通知，通知相关线程，有数据准备好了 
    11. 
   
  
  
  
  11.             enqueue(e); 
    12. 
   
  
  
  
  12.             return true; 
    13. 
   
  
  
  
  13.         } 
    14. 
   
  
  
  
  14.     } finally { 
    15. 
   
  
  
  
  15.         //释放锁了，等着的那个线程，现在可以去弹出一个元素试试了 
    16. 
   
  
  
  
  16.         lock.unlock(); 
    17. 
   
  
  
  
  17.     } 
    18. 
   
  
  
  
  18. } 
    19. 
   
  
  
  
  19.  
    20. 
   
  
  
  
  20. private void enqueue(E x) { 
    21. 
   
  
  
  
  21.     final Object[] items = this.items; 
    22. 
   
  
  
  
  22.     items[putIndex] = x; 
    23. 
   
  
  
  
  23.     if (++putIndex == items.length) 
    24. 
   
  
  
  
  24.         putIndex = 0; 
    25. 
   
  
  
  
  25.     count++; 
    26. 
   
  
  
  
  26.     //元素已经放好了，通知那个等着拿东西的人吧 
    27. 
   
  
  
  
  27.     notEmpty.signal(); 
    28. 
   
  
  
  
  28. } 
    29.

因此，整个流程如图所示：

 

重入锁的使用示例

为了让大家更好的理解重入锁的使用方法。现在我们使用重入锁，实现一个简单的计数器。这个计数器可以保证在多线程环境中，统计数据的精确性，请看下面示例代码：

  
 
 
 
    
   
  
  
  
  1. public class Counter { 
    2. 
   
  
  
  
  2.     //重入锁 
    3. 
   
  
  
  
  3.     private final Lock lock = new ReentrantLock(); 
    4. 
   
  
  
  
  4.     private int count; 
    5. 
   
  
  
  
  5.     public void incr() { 
    6. 
   
  
  
  
  6.         // 访问count时，需要加锁 
    7. 
   
  
  
  
  7.         lock.lock(); 
    8. 
   
  
  
  
  8.         try { 
    9. 
   
  
  
  
  9.             count++; 
    10. 
   
  
  
  
  10.         } finally { 
    11. 
   
  
  
  
  11.             lock.unlock(); 
    12. 
   
  
  
  
  12.         } 
    13. 
   
  
  
  
  13.     } 
    14. 
   
  
  
  
  14.      
    15. 
   
  
  
  
  15.     public int getCount() { 
    16. 
   
  
  
  
  16.         //读取数据也需要加锁，才能保证数据的可见性 
    17. 
   
  
  
  
  17.         lock.lock(); 
    18. 
   
  
  
  
  18.         try { 
    19. 
   
  
  
  
  19.             return count; 
    20. 
   
  
  
  
  20.         }finally { 
    21. 
   
  
  
  
  21.             lock.unlock(); 
    22. 
   
  
  
  
  22.         } 
    23. 
   
  
  
  
  23.     } 
    24. 
   
  
  
  
  24. } 
    25.

总结

可重入锁算是多线程的入门级别知识点，所以我把他当做多线程系列的第一章节，对于重入锁，我们需要特别知道几点：

  1. 对于同一个线程，重入锁允许你反复获得通一把锁，但是，申请和释放锁的次数必须一致。
  2. 默认情况下，重入锁是非公平的，公平的重入锁性能差于非公平锁
  3. 重入锁的内部实现是基于CAS操作的。
  4. 重入锁的伴生对象Condition提供了await()和singal()的功能，可以用于线程间消息通信。

新闻标题：我们聊一聊可重入锁特别重要的话题
文章链接：http://www.stwzsj.com/qtweb/news14/7414.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站内链知识

同城分类信息

注册域名　　 　四川绵阳主机托管　　 　java虚拟主机　　 　成都口碑营销公司　　 　免备案虚拟主机　　 　南充网站建设　　 　成都做网站　　 　成都网站改版　　 　全网营销网站推广　　 　网站运维托管　　 　成都网站运营维护　　 　成都广告制作　　 　蜜朵婚庆　　 　企业手机网站建设　　 　品牌网站建设　　 　华泰海航　　 　移动网站建设　　 　成都定制网站建设　　 　艾名斯线缆　　 　门户网站建设方案