`
lxy2330
  • 浏览: 469291 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

线程高级---读写锁

 
阅读更多
读写锁问题也是比较常见的问题,这是因为现实中充斥着这类问题,而读者写者问题是单纯synchronized的进化版,之所以这么说,是因为它将锁分为读锁和写锁,通过读锁之间的并发性和写锁的排他性从而极大的提升性能。
    在开始之前,还是先来回顾一下读写锁问题。一个数据文件或记录能被多个线程共享。有些线程要求读,而另一些则要求写或修改。允许多个读线程同时读一个共享对象,因为读操作不会使数据文件混乱,但绝不允许一个写线程和其他读或写线程同时访问共享对象。因为这种访问违反了Bernstein条件。
    根据上面的描述,我们可以看出,读锁跟一般的互斥有些不一样,它只互斥写锁,但却不管读锁,换句话说,读锁之间是可以大量并发执行的。这样的例子随处可见,比如,机票售票系统,在买票高峰时期常常都是多个售票窗口同时查询,而不会发生多个人订了同一个座位或者说座位空着却不能订的情况。那么,读写锁在之间是如何发挥其并发的优越性的。当多个售票窗口同时查询时,由于是读取操作,可以同时执行,就是说大家都能看,而不是要排队一个一个看。而一旦有一个人订了票,则在读锁完全解除时,这个写锁就会将票mark为已经购买。之所以不会发生多人同订了一个座位,是因为读锁具有排他性,一旦有个读锁在修改,则不能有其它读锁同时修改。类似的例子还有很多,比如证卷交易等等(注意这里举的两个例子并非是线程的读写锁,通常情况下是利用了关系数据库的读写锁来提升并发性的,这里为了更通俗,从而举这两个常见的例子)
    下图是整个读写锁的框架,对这个框架有个概念性的认识,在复用时需要修改的是哪些?
   
    下面是一个应用读写锁的简单例子。每段程序会加以解读。

/**
 * 2007-6-19
 * Queue.java
 * package ReadWriteLock
 * TODO As a lock
 * levi
 */
package ReadWriteLock;

public class ReadWriteLock {
 private int readingReader;
 private int writingWriter; //0 or 1
 private int waitingWriter;
 private boolean tendWrite;
 
 public synchronized void lockReader(){
  while(writingWriter > 0 || (tendWrite && waitingWriter > 0)){
   try{
    wait();
   }
   catch(InterruptedException ie){
    
   }
  }
  readingReader++;
 }
 
 public synchronized void lockWriter() throws InterruptedException{
  waitingWriter++;
  try{
   while(readingReader > 0 || writingWriter > 0){
    wait();
   }
  }
  finally{
   waitingWriter--;
  }
  writingWriter++;
 }
 
 public synchronized void unlockReader(){
  readingReader--;
  tendWrite = true;
  notifyAll();
 }
 
 public synchronized void unlockWriter(){
  writingWriter--;
  tendWrite = false;
  notifyAll();
 }
}

     这里设置了4个变量readingReader,writingWriter,waitingWriter,tendWrite,分别代表正在读的读者,正在写的写者,等待中的写者以及一个用来评估读还是写的判断条件。这个评估条件是非常有用的,它能够保证程序不会只运行读线程(因为读的量较大),而是适当的让出一些机会给写线程。读锁定中while(writingWriter > 0 || (tendWrite && waitingWriter > 0)) 就是存在正在写的线程(意味着现在的机会在写线程手中)或者评估为写并且正在等待的写线程超过一个(意味着之后的机会应该给写线程)那就得等待。而写锁的等待条件则是while(readingReader > 0 || writingWriter > 0) 意味着有正在运行的读或写线程,则必须等待,这体现了写的排他性。而这里waitingWriter++;后面又 finally{waitingWriter--;}可能觉得很奇怪,怎么加一会减一会的,其实这里用到了线程设计的before/after pattern,只有当进入wait而没有发生任何错我们才知道它在等待,可惜我们没办法在wait里设置,于是before wait,我们就用了waitingWriter++;表示已经开始等待了,而无论是被中断取消或是正常唤醒,我们都要waitingWriter--; 表示结束。解锁就不在解释了,注意观察评估变量的设定及其作用。

/**
 * 2007-6-19
 * Queue.java
 * package ReadWriteLock
 * TODO As a shared concurrent resource
 * levi
 */
package ReadWriteLock;


import java.util.*;
/**
 * @author levi
 *
 */
public class Queue {
 private LinkedList queue = new LinkedList();
 private ReadWriteLock rwLock = new ReadWriteLock();

 public Queue(String str){
  StringTokenizer st = new StringTokenizer(str.toString());
  while(st.hasMoreTokens())
   queue.add(st.nextToken());
 }
 
 public Object read() throws InterruptedException{
  rwLock.lockReader();
  try{
   String s = "";
   for(int i = 0;i < queue.size();i++){
    s += queue.remove(0);
   }
   return s;
  }
  finally{
   rwLock.unlockReader();
  }
 }
 
 public void write(Object obj) throws InterruptedException{
  rwLock.lockWriter();
 
  try{
   StringTokenizer st = new StringTokenizer(obj.toString());
   while(st.hasMoreTokens())
    queue.add(st.nextToken());
  }
  finally{
   rwLock.unlockWriter();
  }
 }
}

     这个类是实际的资源类,主要就是read和write方法,read负责读出所有对象并将队列清空,而write负责写入对象。注意读写锁的使用。

     注意这里是通过两个逻辑上实现的lockReader和lockWriter来锁定程序,跟synchronized不同的是,这两个锁实际上用到了synchronized,只是比它多了些判读条件。

/**
 * 2007-6-19
 * Reader.java
 * package ReadWriteLock
 * TODO As a reader to read data concurrently from queue
 * levi
 */
package ReadWriteLock;

public class Reader extends Thread{
 
 private Queue queue;
 
 public Reader(Queue queue){
  this.queue = queue;
 }
 
 public void run(){
  try{
   System.out.println(Thread.currentThread().getName() + " Query: " + queue.read().toString());
  }
  catch(InterruptedException ie){
   
  }
 }
}

     Reader类。就是将read读入的内容显示出来。

 

/**
 * 2007-6-19
 * Writer.java
 * package ReadWriteLock
 * TODO As a writer to write data to queue
 * levi
 */
package ReadWriteLock;

public class Writer extends Thread{
 private Queue queue;
 private String request;
 
 public Writer(Queue queue,String request){
  this.queue = queue;
  this.request = request;
 }
 
 public void run(){
  try{
   queue.write(request);
  }
  catch(InterruptedException ie){
   
  }
 }
}

     Writer。负责写入一个request

 

/**
 * 2007-6-19
 * Test.java
 * package ReadWriteLock
 * TODO the main thread
 * levi
 */
package ReadWriteLock;

/**
 * @author levi
 *
 */
public class Test {
 public static void main(String [] args){
  Queue q = new Queue("* * * * * * * * * *");
  new Writer(q,"I find that I had fallen into you, beautiful girl").start();
  new Writer(q,"But also I am wasting my time,flower becomes air").start();
  new Reader(q).start();
  new Reader(q).start();
  new Reader(q).start();
  new Reader(q).start();
  new Reader(q).start();
  
 }
}

    主测试类。主要负责调用Reader和Writer

 

    最后,值得提醒的是,类似这样的问题都能抽象出一个共同的特征:那就是读线程比较多或者读操作比较繁重。如果大多数线程是写操作的话,就得评估衡量用读写锁来解决是否合算了。

分享到:
评论

相关推荐

    易语言线程安全之原子锁与读写锁

    读写锁则是一种更高级的同步机制,它允许多个线程同时读取共享资源,但只允许一个线程进行写入。这种锁的特性提高了多线程环境下的并发性能,因为读操作通常是无冲突的。在易语言中,我们可以使用读写锁类来实现这一...

    操作系统实验--读写锁

    3. **锁升级与降级**:在某些高级实现中,读写锁支持锁升级和降级的概念。如果一个线程先持有了读锁,然后发现自己需要进行写操作,它可以升级为写锁。写操作完成后,如果可能,该线程可以降级回读锁,而不必立即...

    线程间同步机制 读写锁通信机制 线程与信号

    在Linux高级程序设计中,主要介绍了三种线程同步机制:互斥锁、条件变量和读写锁,以及线程与信号的交互。 1. **互斥锁通信机制**: 互斥锁是用于保护临界区的一种机制,确保同一时间只有一个线程能访问共享资源。...

    计算机软件-商业源码-利用读写锁保持线程同步.zip

    - **升级与降级**:某些高级读写锁支持读锁到写锁的升级或写锁到读锁的降级,这在某些复杂场景中很有用。 5. **Java中的ReentrantReadWriteLock**: Java的`ReentrantReadWriteLock`提供了可重入的读写锁功能,...

    windows 读写锁 (基于关键区的读写锁类 及自动锁)

    其中,读写锁(Read-Write Lock,简称RWLock)是一种高效的线程同步机制,适用于大量读取操作和少量写入操作的情况。在本文中,我们将深入探讨基于关键区的Windows读写锁类及其自动锁的实现原理和改进点。 读写锁的...

    java多线程-读写锁原理

    在Java多线程编程中,读写锁是一种高级的同步机制,它允许多个线程同时读取共享资源,但只允许一个线程写入。这种锁的引入提高了并发性能,特别是在读操作远多于写操作的场景下。Java 5开始,`java.util.concurrent....

    利用读写锁保持线程同步.zip

    读写锁是一种高级的线程同步机制,它允许多个读线程同时访问资源,而当有写线程正在操作时,所有其他线程(无论是读还是写)都会被阻塞,直到写操作完成。 在C++中,标准库提供了一个名为`std::shared_timed_mutex`...

    File 线程读写

    在读写文件时,可以使用文件锁来防止多个线程同时写入。 4. **缓冲区(Buffer)与非阻塞IO**: - 使用缓冲区可以提高文件读写的效率,减少系统调用的次数。Java NIO(New IO)提供了缓冲区API,可以配合通道进行非...

    iOS线程读写安全

    在读写锁中,多个读线程可以同时访问共享资源,而写线程则具有独占性,即当一个线程在写入时,其他所有线程(无论是读还是写)都将被阻塞,直到写操作完成。读写锁通过这种方式提高了并发性能,因为在大多数情况下,...

    读写锁实现例子

    读写锁是一种高级的同步机制,它允许多个线程同时读取共享资源,但只允许一个线程进行写操作。这在数据读取远比写入频繁的情况下可以显著提高系统的性能。 读写锁的核心在于它的两个主要方法:`ReadLock()` 和 `...

    读写锁源代码(C#编写)

    读写锁是多线程编程中的一个重要概念,它在C#中被广泛应用于提高并发访问数据的效率。本文将深入探讨C#中的读写锁及其使用,帮助你理解和掌握这一关键技能。 首先,读写锁提供了对共享资源的细粒度控制。在C#中,`...

    易语言线程安全之原子锁与读写锁-易语言

    "易语言线程安全之原子锁与读写锁"的主题涉及到两种用于实现线程安全的机制:原子操作和读写锁。 首先,我们来讨论原子操作。原子操作是一种特殊的操作,它不可分割,即在执行过程中不会被其他线程中断。在易语言中...

    linux下实现高性能读写锁(read/write lock)

    在Linux系统中,读写锁(Read/Write Locks,简称rwlocks)是一种多线程同步机制,它允许多个线程同时进行读操作,但只允许一个线程执行写操作。这种锁的设计目的是提高并发性能,特别是当读操作远多于写操作时。在...

    标准C写的线程池和读写锁

    读写锁(Read-Write Locks)是一种高级的锁机制,允许多个读线程同时访问共享资源,但写操作必须互斥进行。这样可以提高多线程环境下的并发性能。"rwlock.c"和"rwlock.h"文件包含了读写锁的实现,它通常包括获取读锁...

    行业分类-设备装置-双模式读写锁.zip

    3. **升级与降级**:某些高级读写锁还支持锁的升级和降级。这意味着一个已经持有读锁的线程在需要进行写操作时,可以不释放读锁直接升级为写锁,完成写操作后再降级回读锁。这样的设计可以在某些场景下减少锁竞争,...

    Java 多线程与并发(10-26)-JUC锁- 锁核心类AQS详解.pdf

    它是实现Java并发包中锁和其他同步器的基础框架,例如ReentrantLock(可重入锁)、Semaphore(信号量)、CountDownLatch(倒计时门闩)、CyclicBarrier(循环栅栏)以及ReentrantReadWriteLock(可重入读写锁)等。...

    线程互斥锁

    对于大块代码,可以考虑使用读写锁或者自旋锁等更细粒度的同步机制。 总的来说,线程互斥锁是保证多线程环境下数据一致性的重要工具,它的正确使用对于编写可扩展和可靠的并发程序至关重要。通过理解不同操作系统下...

    线程同步方法--Metux 实例

    在网络编程中,线程同步尤其重要,因为网络I/O操作通常是异步的,可能会引发多个线程同时对数据进行读写。在服务器端,线程可能需要处理并发的客户端请求,正确地同步这些线程可以确保服务的稳定性和响应速度。 ...

    java线程 线程学习资料 java线程教程

    ### Java线程教程知识点梳理 #### 一、教程概述 - **目标读者**: 本教程主要面向具备丰富Java基础知识但缺乏...此外,深入学习线程间通信、同步机制以及高级主题,将为解决实际项目中的多线程编程挑战打下坚实的基础。

Global site tag (gtag.js) - Google Analytics