java 读写锁详解

简介:

在java多线程中,为了提高效率有些共享资源允许同时进行多个读的操作,但只允许一个写的操作,比如一个文件,只要其内容不变可以让多个线程同时读,不必做排他的锁定,排他的锁定只有在写的时候需要,以保证别的线程不会看到数据不完整的文件。

   下面是个关于多线程读写锁的例子,我稍微做了下修改,蛮容易理解的,来至于http://www.highya.com/redirect.php?fid=113&tid=7180&goto=nextoldset。

这里模拟了这样一个场景: 在ReadWriteLockOperator对象里设置一个共享资源 shareResources 。

有3个读者(A, B, C)一直连续的从 shareResources 获取信息, 然后输出到控制台 ;有一个作者每隔60秒往shareResources 加入信息, 加信息的过程相对耗时, 在这段时间, 任何读者都不能访问 shareResources。

  写了4个类来验证这种情况,只在windows下做了测试。

  ReadTask.java       读任务

  WriteTask.java      写任务

  ReadWriteLockLogic.java     读写操作的逻辑

  ReadWriteLockTest.java      带有main方法的测试类

---------------------------------------混哥线-----------------------------------------------    

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public  class  ReadTask  extends  Thread {
   //logic bean
   private  ReadWriteLockLogic readWriteLockOperator;
   //读者
   private  String reader;
   public  ReadTask(ReadWriteLockLogic readWriteLockOperator, String reader) {
     this .readWriteLockOperator = readWriteLockOperator;
     this .reader = reader;
   }
   private  ReadTask(){}
   // 执行任务
   public  void  run() {
     if ( this .readWriteLockOperator !=  null ){
       try  {
         while (!isInterrupted()){
           Thread.sleep( 200 );
           System.out.println(reader +  " read:" 
           + Thread.currentThread().toString() +  " : "  this .readWriteLockOperator.read());
         }
       catch  (Exception e) {
         // TODO: handle exception
       }
     }
   }
}

-------------------------------------------------------------------------------------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public  class  WriteTask   extends  Thread{
   //logic bean
   private  ReadWriteLockLogic readWriteLockOperator;
   //作者
   private  String writer;
   public  WriteTask(ReadWriteLockLogic readWriteLockOperator, String writer) {
     this .readWriteLockOperator = readWriteLockOperator;
     this .writer = writer;
   }
   private  WriteTask(){}
   // 一个很耗时的写任务
   public  void  run() {
     try  {
       while (!isInterrupted()){
         Thread.sleep( 100 );
         this .readWriteLockOperator.write( this .writer,  "hehehhe" );
       }
     catch  (Exception e) {
       // TODO: handle exception
     }
   }
}

----------------------------------------------------------------------------------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
import  java.util.ArrayList;
import  java.util.List;
import  java.util.concurrent.locks.Lock;
import  java.util.concurrent.locks.ReadWriteLock;
import  java.util.concurrent.locks.ReentrantReadWriteLock;
//读写操作的逻辑
public  class  ReadWriteLockLogic {
   // 初始化一个 ReadWriteLock
   private  ReadWriteLock lock =  new  ReentrantReadWriteLock();
   //共享资源
   private  List<String> shareResources =  new  ArrayList<String>( 0 );
   //读
   public  String read() {
     // 得到 readLock 并锁定
     Lock readLock = lock.readLock();
     readLock.lock();
     try  {
       // 读相对省时,做空循环 大约0.5second
       for ( int  i= 0  ;i< 2500000 ; i++){
         System.out.print( "" );
       }
       // 做读的工作
       StringBuffer buffer =  new  StringBuffer();
       for  (String shareResource : shareResources) {
         buffer.append(shareResource);
         buffer.append( "\t" );      
       }
       return  buffer.toString();
     finally  {
       readLock.unlock(); //一定要保证锁的释放
     }
   }
   //写
   public  void  write(String writer, String content) {
     // 得到 writeLock 并锁定
     Lock writeLock = lock.writeLock();
     writeLock.lock();
     try  {
       System.out.println(writer +  " write ==="  + Thread.currentThread().toString());
       // 写比较费时,所以做空循环 大约13second
       for ( int  i= 0  ;i< 10000000 ; i++){
         System.out.print( "" );
         System.out.print( "" );
       }
     
       // 做写的工作
       int  count = shareResources.size();
       for  ( int  i=count; i < count +  1 ; i++) {
         shareResources.add(content +  "_"  + i);
       }
     finally  {
       writeLock.unlock(); //一定要保证锁的释放
     }
   }
}

------------------------------------------------------------------------------------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import  java.util.concurrent.ExecutionException;
import  java.util.concurrent.Executors;
import  java.util.concurrent.ScheduledExecutorService;
import  java.util.concurrent.TimeUnit;
public  class  ReadWriteLockTest {
   public  static  void  main(String[] args)  throws  InterruptedException, ExecutionException {
     //1 创建一个具有排程功能的线程池
     ScheduledExecutorService service = Executors.newScheduledThreadPool( 5 );
     //2 读写锁的logic bean
     ReadWriteLockLogic lockOperator =  new  ReadWriteLockLogic();
     //3 生成一个可执行任务(该任务执行完毕可以返回结果 或者 抛出异常;而Runnable接口的run方法则不行)
     Runnable writeTask1 =  new  WriteTask(lockOperator,  "作者A" );
     //4 延时0秒后每2秒重复执行writeTask1;
     service.scheduleAtFixedRate(writeTask1,  0 60 , TimeUnit.SECONDS);
     //5 创建3个读任务
     Runnable readTask1 =  new  WriteTask(lockOperator,  "作者B" );
     Runnable readTask2 =  new  ReadTask(lockOperator,  "读者B" );
     Runnable readTask3 =  new  ReadTask(lockOperator,  "读者C" );
     //6 延时0秒后每秒执行一次task1;
     service.scheduleAtFixedRate(readTask1,  1 1 , TimeUnit.SECONDS);
     service.scheduleAtFixedRate(readTask2,  2 1 , TimeUnit.SECONDS);
     service.scheduleAtFixedRate(readTask3,  3 1 , TimeUnit.SECONDS);
   
   }
}

----------------------------------------------------------------------------------------

作者A write ===Thread[pool-1-thread-1,5,main]

作者B write ===Thread[pool-1-thread-4,5,main]

读者C read:Thread[pool-1-thread-3,5,main] : hehehhe_0 hehehhe_1 

读者B read:Thread[pool-1-thread-2,5,main] : hehehhe_0 hehehhe_1

作者A write ===Thread[pool-1-thread-1,5,main]

................

通过观察控制台,可以看到作者a出现后,大约5秒作者b才会出现,而又过了5秒后,读者c和读者b同时会出现,接着5秒后,作者a又出现了。这说明了,读锁之间没有排斥,可以多线程持有并且排斥WriteLock的持有线程。而WriteLock是全部排斥的,是独占的,比较独!

 

下面是附赠的读写锁的小知识,来至http://www.txdnet.cn/essay/view.jsp?tid=1288670091703&cid=2

(a).重入方面其内部的WriteLock可以获取ReadLock,但是反过来ReadLock想要获得WriteLock则永远都不要想.

(b).WriteLock可以降级为ReadLock,顺序是:先获得WriteLock再获得ReadLock,然后释放WriteLock,这时候线程将保持Readlock的持有.反过来ReadLock想要升级为WriteLock则不可能,为什么?参看(a),呵呵.

(c).ReadLock可以被多个线程持有并且在作用时排斥任何的WriteLock,而WriteLock则是完全的互斥.这一特性最为重要,因为对于高读取频率而相对较低写入的数据结构,使用此类锁同步机制则可以提高并发量.

(d).不管是ReadLock还是WriteLock都支持Interrupt,语义与ReentrantLock一致.

(e).WriteLock支持Condition并且与ReentrantLock语义一致,而ReadLock则不能使用Condition,否则抛出UnsupportedOperationException异常.


特别说明:尊重作者的劳动成果,转载请注明出处哦~~~
相关文章
|
9天前
|
安全 Java 调度
Java编程时多线程操作单核服务器可以不加锁吗?
Java编程时多线程操作单核服务器可以不加锁吗?
26 2
|
2月前
|
存储 Oracle 安全
揭秘Java并发核心:深入Hotspot源码腹地,彻底剖析Synchronized关键字的锁机制与实现奥秘!
【8月更文挑战第4天】在Java并发世界里,`Synchronized`如同导航明灯,确保多线程环境下的代码安全执行。它通过修饰方法或代码块实现独占访问。在Hotspot JVM中,`Synchronized`依靠对象监视器(Object Monitor)机制实现,利用对象头的Mark Word管理锁状态。
43 1
|
24天前
|
存储 缓存 安全
【Java面试题汇总】多线程、JUC、锁篇(2023版)
线程和进程的区别、CAS的ABA问题、AQS、哪些地方使用了CAS、怎么保证线程安全、线程同步方式、synchronized的用法及原理、Lock、volatile、线程的六个状态、ThreadLocal、线程通信方式、创建方式、两种创建线程池的方法、线程池设置合适的线程数、线程安全的集合?ConcurrentHashMap、JUC
【Java面试题汇总】多线程、JUC、锁篇(2023版)
|
12天前
|
算法 Java 关系型数据库
Java中到底有哪些锁
【9月更文挑战第24天】在Java中,锁主要分为乐观锁与悲观锁、自旋锁与自适应自旋锁、公平锁与非公平锁、可重入锁以及独享锁与共享锁。乐观锁适用于读多写少场景,通过版本号或CAS算法实现;悲观锁适用于写多读少场景,通过加锁保证数据一致性。自旋锁与自适应自旋锁通过循环等待减少线程挂起和恢复的开销,适用于锁持有时间短的场景。公平锁按请求顺序获取锁,适合等待敏感场景;非公平锁性能更高,适合频繁加解锁场景。可重入锁支持同一线程多次获取,避免死锁;独享锁与共享锁分别用于独占和并发读场景。
|
20天前
|
Java 数据库
JAVA并发编程-一文看懂全部锁机制
曾几何时,面试官问:java都有哪些锁?小白,一脸无辜:用过的有synchronized,其他不清楚。面试官:回去等通知! 今天我们庖丁解牛说说,各种锁有什么区别、什么场景可以用,通俗直白的分析,让小白再也不怕面试官八股文拷打。
|
20天前
|
安全 Java 开发者
Java并发编程中的锁机制解析
本文深入探讨了Java中用于管理多线程同步的关键工具——锁机制。通过分析synchronized关键字和ReentrantLock类等核心概念,揭示了它们在构建线程安全应用中的重要性。同时,文章还讨论了锁机制的高级特性,如公平性、类锁和对象锁的区别,以及锁的优化技术如锁粗化和锁消除。此外,指出了在高并发环境下锁竞争可能导致的问题,并提出了减少锁持有时间和使用无锁编程等策略来优化性能的建议。最后,强调了理解和正确使用Java锁机制对于开发高效、可靠并发应用程序的重要性。
18 3
|
2月前
|
存储 Java
Java锁是什么?简单了解
在高并发环境下,锁是Java中至关重要的概念。锁或互斥是一种同步机制,用于限制多线程环境下的资源访问,确保排他性和并发控制。例如,超市储物柜仅能存放一个物品,若三人同时使用,则需通过锁机制确保每次只有一个线程访问。Java中可以通过`synchronized`关键字实现加锁,确保关键代码段的原子性,避免数据不一致问题。正确使用锁可有效提升程序的稳定性和安全性。
Java锁是什么?简单了解
|
2月前
|
小程序 Java 开发工具
【Java】@Transactional事务套着ReentrantLock锁,锁竟然失效超卖了
本文通过一个生动的例子,探讨了Java中加锁仍可能出现超卖问题的原因及解决方案。作者“JavaDog程序狗”通过模拟空调租赁场景,详细解析了超卖现象及其背后的多线程并发问题。文章介绍了四种解决超卖的方法:乐观锁、悲观锁、分布式锁以及代码级锁,并重点讨论了ReentrantLock的使用。此外,还分析了事务套锁失效的原因及解决办法,强调了事务边界的重要性。
59 2
【Java】@Transactional事务套着ReentrantLock锁,锁竟然失效超卖了
|
1月前
|
Oracle Java 关系型数据库
【颠覆性升级】JDK 22:超级构造器与区域锁,重塑Java编程的两大基石!
【9月更文挑战第6天】JDK 22的发布标志着Java编程语言在性能和灵活性方面迈出了重要的一步。超级构造器和区域锁这两大基石的引入,不仅简化了代码设计,提高了开发效率,还优化了垃圾收集器的性能,降低了应用延迟。这些改进不仅展示了Oracle在Java生态系统中的持续改进和创新精神,也为广大Java开发者提供了更多的可能性和便利。我们有理由相信,在未来的Java编程中,这些新特性将发挥越来越重要的作用,推动Java技术不断向前发展。
|
2月前
|
Java 开发者
Java多线程教程:使用ReentrantLock实现高级锁功能
Java多线程教程:使用ReentrantLock实现高级锁功能
34 1
下一篇
无影云桌面