`
wsmajunfeng
  • 浏览: 497384 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

(转)深入研究ReentrantLock(重入锁)之引出话题篇

 
阅读更多

一直以来都想好好研究下ReentrantLock,她的独到魅力令我屡试不爽,无奈网上实在是没有太多的资料可以参考,于是自己开始深入研究它的内部实现机制,经过数天的研究,终于有点心得体会升华了,记录之……

synchronized原语和ReentrantLock在一般情况下没有什么区别,但是在非常复杂的同步应用中,请考虑使用ReentrantLock,特别是遇到下面2种需求的时候。
1.某个线程在等待一个锁的控制权的这段时间需要中断
2.需要分开处理一些wait-notify,ReentrantLock里面的Condition应用,能够控制notify哪个线程
3.具有公平锁功能,每个到来的线程都将排队等候
下面细细道来……

先说第一种情况,ReentrantLock的lock机制有2种,忽略中断锁和响应中断锁,这给我们带来了很大的灵活性。比如:如果A、B2个 线程去竞争锁,A线程得到了锁,B线程等待,但是A线程这个时候实在有太多事情要处理,就是一直不返回,B线程可能就会等不及了,想中断自己,不再等待这 个锁了,转而处理其他事情。这个时候ReentrantLock就提供了2种机制,第一,B线程中断自己(或者别的线程中断它),但是 ReentrantLock不去响应,继续让B线程等待,你再怎么中断,我全当耳边风(synchronized原语就是如此);第二,B线程中断自己 (或者别的线程中断它),ReentrantLock处理了这个中断,并且不再等待这个锁的到来,完全放弃。(如果你没有了解java的中断机制,请参考 下相关资料,再回头看这篇文章,80%的人根本没有真正理解什么是java的中断,呵呵)

这里来做个试验,首先搞一个Buffer类,它有读操作和写操作,为了不读到脏数据,写和读都需要加锁,我们先用synchronized原语来加锁,如下:

Java代码  收藏代码
  1. public   class  Buffer {   
  2.     
  3.     private  Object lock;   
  4.     
  5.     public  Buffer() {   
  6.         lock = this ;   
  7.     }   
  8.     
  9.     public   void  write() {   
  10.         synchronized  (lock) {   
  11.             long  startTime = System.currentTimeMillis();   
  12.             System.out.println("开始往这个buff写入数据…" );   
  13.             for  (;;) // 模拟要处理很长时间    
  14.             {   
  15.                 if  (System.currentTimeMillis()   
  16.                         - startTime > Integer.MAX_VALUE)   
  17.                     break ;   
  18.             }   
  19.             System.out.println("终于写完了" );   
  20.         }   
  21.     }   
  22.     
  23.     public   void  read() {   
  24.         synchronized  (lock) {   
  25.             System.out.println("从这个buff读数据" );   
  26.         }   
  27.     }   
  28. }   


接着,我们来定义2个线程,一个线程去写,一个线程去读。

Java代码  收藏代码
  1. public   class  Writer  extends  Thread {   
  2.     
  3.     private  Buffer buff;   
  4.     
  5.     public  Writer(Buffer buff) {   
  6.         this .buff = buff;   
  7.     }   
  8.     
  9.     @Override    
  10.     public   void  run() {   
  11.         buff.write();   
  12.     }   
  13.     
  14. }   
  15.     
  16. public   class  Reader  extends  Thread {   
  17.     
  18.     private  Buffer buff;   
  19.     
  20.     public  Reader(Buffer buff) {   
  21.         this .buff = buff;   
  22.     }   
  23.     
  24.     @Override    
  25.     public   void  run() {   
  26.     
  27.         buff.read();//这里估计会一直阻塞    
  28.     
  29.         System.out.println("读结束" );   
  30.     
  31.     }   
  32.     
  33. }   


好了,写一个Main来试验下,我们有意先去“写”,然后让“读”等待,“写”的时间是无穷的,就看“读”能不能放弃了。

Java代码  收藏代码
  1. public   class  Test {   
  2.     public   static   void  main(String[] args) {   
  3.         Buffer buff = new  Buffer();   
  4.     
  5.         final  Writer writer =  new  Writer(buff);   
  6.         final  Reader reader =  new  Reader(buff);   
  7.     
  8.         writer.start();   
  9.         reader.start();   
  10.     
  11.         new  Thread( new  Runnable() {   
  12.     
  13.             @Override    
  14.             public   void  run() {   
  15.                 long  start = System.currentTimeMillis();   
  16.                 for  (;;) {   
  17.                     //等5秒钟去中断读    
  18.                     if  (System.currentTimeMillis()   
  19.                             - start > 5000 ) {   
  20.                         System.out.println("不等了,尝试中断" );   
  21.                         reader.interrupt();   
  22.                         break ;   
  23.                     }   
  24.     
  25.                 }   
  26.     
  27.             }   
  28.         }).start();   
  29.     
  30.     }   
  31. }   


我们期待“读”这个线程能退出等待锁,可是事与愿违,一旦读这个线程发现自己得不到锁,就一直开始等待了,就算它等死,也得不到锁,因为写线程要 21亿秒才能完成 T_T ,即使我们中断它,它都不来响应下,看来真的要等死了。这个时候,ReentrantLock给了一种机制让我们来响应中断,让“读”能伸能屈,勇敢放弃 对这个锁的等待。我们来改写Buffer这个类,就叫BufferInterruptibly吧,可中断缓存。

Java代码  收藏代码
  1. import  java.util.concurrent.locks.ReentrantLock;   
  2.     
  3. public   class  BufferInterruptibly {   
  4.     
  5.     private  ReentrantLock lock =  new  ReentrantLock();   
  6.     
  7.     public   void  write() {   
  8.         lock.lock();   
  9.         try  {   
  10.             long  startTime = System.currentTimeMillis();   
  11.             System.out.println("开始往这个buff写入数据…" );   
  12.             for  (;;) // 模拟要处理很长时间    
  13.             {   
  14.                 if  (System.currentTimeMillis()   
  15.                         - startTime > Integer.MAX_VALUE)   
  16.                     break ;   
  17.             }   
  18.             System.out.println("终于写完了" );   
  19.         } finally  {   
  20.             lock.unlock();   
  21.         }   
  22.     }   
  23.     
  24.     public   void  read()  throws  InterruptedException {   
  25.         lock.lockInterruptibly();// 注意这里,可以响应中断    
  26.         try  {   
  27.             System.out.println("从这个buff读数据" );   
  28.         } finally  {   
  29.             lock.unlock();   
  30.         }   
  31.     }   
  32.     
  33. }   


当然,要对reader和writer做响应的修改

Java代码  收藏代码
  1. public   class  Reader  extends  Thread {   
  2.     
  3.     private  BufferInterruptibly buff;   
  4.     
  5.     public  Reader(BufferInterruptibly buff) {   
  6.         this .buff = buff;   
  7.     }   
  8.     
  9.     @Override    
  10.     public   void  run() {   
  11.     
  12.         try  {   
  13.             buff.read();//可以收到中断的异常,从而有效退出    
  14.         } catch  (InterruptedException e) {   
  15.             System.out.println("我不读了" );   
  16.         }   
  17.           
  18.         System.out.println("读结束" );   
  19.     
  20.     }   
  21.     
  22. }   
  23.     
  24. /**   
  25. * Writer倒不用怎么改动   
  26. */    
  27. public   class  Writer  extends  Thread {   
  28.     
  29.     private  BufferInterruptibly buff;   
  30.     
  31.     public  Writer(BufferInterruptibly buff) {   
  32.         this .buff = buff;   
  33.     }   
  34.     
  35.     @Override    
  36.     public   void  run() {   
  37.         buff.write();   
  38.     }   
  39.     
  40. }   
  41.     
  42. public   class  Test {   
  43.     public   static   void  main(String[] args) {   
  44.         BufferInterruptibly buff = new  BufferInterruptibly();   
  45.     
  46.         final  Writer writer =  new  Writer(buff);   
  47.         final  Reader reader =  new  Reader(buff);   
  48.     
  49.         writer.start();   
  50.         reader.start();   
  51.     
  52.         new  Thread( new  Runnable() {   
  53.     
  54.             @Override    
  55.             public   void  run() {   
  56.                 long  start = System.currentTimeMillis();   
  57.                 for  (;;) {   
  58.                     if  (System.currentTimeMillis()   
  59.                             - start > 5000 ) {   
  60.                         System.out.println("不等了,尝试中断" );   
  61.                         reader.interrupt();   
  62.                         break ;   
  63.                     }   
  64.     
  65.                 }   
  66.     
  67.             }   
  68.         }).start();   
  69.     
  70.     }   
  71. }   

这次“读”线程接收到了lock.lockInterruptibly()中断,并且有效处理了这个“异常”。好奇的读者,肯定要探个究竟,为什么ReentrantLock能做到这点,接下来,我们去迷宫探险吧……

分享到:
评论

相关推荐

    教你完全理解ReentrantLock重入锁

    ReentrantLock重入锁,是实现Lock接口的一个类,也是在实际编程中使用频率很高的一个锁,支持重入性,表示能够对共享资源能够重复加锁,即当前线程获取该锁再次获取不会被阻塞。在java关键字synchronized隐式支持重...

    手写可重入锁

    可重入锁,也称为递归锁,是Java并发编程中的一个重要概念,主要在`java.util.concurrent.locks.ReentrantLock`类中实现。这个概念对于理解多线程环境下的同步控制至关重要,尤其对于初学者来说,掌握其原理和用法...

    自己动手写一把可重入锁测试案例

    本篇将基于《Java并发编程:自己动手写一把可重入锁》一文中的案例,深入探讨可重入锁的概念、原理以及如何实现一个简单的可重入锁。 可重入锁,顾名思义,就是可以被同一线程重复获取的锁。当一个线程已经持有锁的...

    Java并发之ReentrantLock类源码解析

    ReentrantLock是Java并发包中的一种同步工具,它可以实现可重入锁的功能。ReentrantLock类的源码分析对理解Java并发机制非常重要。本文将对ReentrantLock类的源码进行详细分析,涵盖ReentrantLock的继承关系、构造...

    Java源码解析之可重入锁ReentrantLock

    Java源码解析之可重入锁ReentrantLock ReentrantLock是一个可重入锁,在ConcurrentHashMap中使用了ReentrantLock。它是一个可重入的排他锁,它和synchronized的方法和代码有着相同的行为和语义,但有更多的功能。 ...

    ReentrantLock源码详解--公平锁、非公平锁

    ReentrantLock是一种重入锁,实现了Lock接口,能够对共享资源重复加锁,即当前线程获取该锁再次获取不会被阻塞。ReentrantLock的可重入性是通过继承AQS(AbstractQueuedSynchronizer)实现的。 ReentrantLock的主要...

    ReentrantLock源码的使用问题详解.docx

    ReentrantLock,可重入锁,是Java并发编程中一个重要的锁实现,它提供了比synchronized更高级别的控制能力,包括公平性和非公平性选择。本文将深入探讨ReentrantLock的原理,特别是其公平锁与非公平锁的概念,以及...

    Java多线程高并发篇(一)--重入锁

    本篇文章将深入探讨重入锁的相关知识点。 首先,重入锁是Java并发包`java.util.concurrent.locks`中的一个类,名为`ReentrantLock`。它的名字“重入”来源于其特性,即允许同一个线程多次获取同一把锁。这与内置锁...

    7、深入理解AQS独占锁之ReentrantLock源码分析(1).pdf

    根据给定文件的信息,我们可以深入理解AQS(AbstractQueuedSynchronizer)独占锁之ReentrantLock的源码分析及其实现原理。这不仅包括ReentrantLock本身的特性,还包括了其背后的AQS框架是如何工作的。 ### 一、管程...

    ReentrantLock解析

    在Java并发编程中,ReentrantLock是JDK提供的一个可重入互斥锁,它是java.util.concurrent.locks包下的核心类。与synchronized关键字相比,ReentrantLock提供了更高的灵活性,如尝试加锁、定时加锁和公平锁等功能。...

    简单聊聊Synchronized和ReentrantLock锁.docx

    相比之下,ReentrantLock(可重入锁)是Java并发包java.util.concurrent.locks中的一个类,提供了更细粒度的锁控制。ReentrantLock允许显式获取和释放锁,并且支持更丰富的锁原语,如公平锁、非公平锁、可中断锁、...

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

    分布式可重入锁是分布式系统中解决并发控制和同步问题的关键技术之一,特别是在微服务架构中,多个服务可能需要共享同一资源,此时就需要一种机制来确保数据的一致性和正确性。Redis,作为一个高性能的键值存储系统...

    各种锁汇总,乐观锁、悲观锁、分布式锁、可重入锁、互斥锁、读写锁、分段锁、类锁、行级锁等

    本文将深入探讨标题和描述中提及的各种锁,包括乐观锁、悲观锁、分布式锁、可重入锁、互斥锁、读写锁、分段锁、类锁以及行级锁。 1. **乐观锁**:乐观锁假设多线程环境中的冲突较少,所以在读取数据时不加锁,只有...

    Java可重入锁的实现原理与应用场景

    ReentrantLock是一个可重入锁的实现类,可以手动控制锁的获取和释放。synchronized是Java语言的关键字,用于同步方法或代码块,但是synchronized也是一种可重入锁。 在使用可重入锁时,需要注意以下几点: * 可重...

    java ReentrantLock详解.docx

    相较于`synchronized`,`ReentrantLock`的主要优势在于其灵活性、可重入性和可中断性。 1. **可重入性**: 无论是`synchronized`还是`ReentrantLock`,都支持可重入特性。这意味着一个线程可以多次获取同一锁,...

    Java并发编程之显示锁ReentrantLock和ReadWriteLock读写锁

    ReentrantLock是一个可重入的锁,这意味着一个线程可以多次获取同一锁,这与synchronized内置锁的行为相同。然而,与内置锁不同的是,使用ReentrantLock需要显式调用`lock()`和`unlock()`方法来获取和释放锁,这增加...

    第五章 ReentrantLock源码解析1--获得非公平锁与公平锁lock()1

    本篇文章将深入解析ReentrantLock的源码,重点讨论非公平锁和公平锁的获取过程。 1. **ReentrantLock的基本概念** ReentrantLock是由Java提供的可重入互斥锁,支持公平锁和非公平锁两种模式。非公平锁的特性是获取...

    ReentrantLock 实现原理 1

    ReentrantLock 的实现原理基于 AQS(AbstractQueuedSynchronizer),是一个重入锁,允许一个线程反复地获取锁而不会出现自己阻塞自己的情况。 ReentrantLock 的构造方法可以指定锁的类型,包括公平锁和非公平锁。...

    ReentrantLock代码剖析之ReentrantLock_lock

    如果线程在持有锁的过程中再次请求锁,`ReentrantLock`允许线程重入,这就是“可重入”的含义。释放锁时,`state`会递减,直到`state`变为0,表示锁已经被完全释放。 在等待队列中,线程会进入阻塞状态,等待被唤醒...

Global site tag (gtag.js) - Google Analytics