程序博客网 > 2016知乎日报启动画面

【Java并发编程实战】—–“J.U.C”：ReentrantReadWriteLock

来源：互联网 发布：2016知乎日报启动画面 编辑：程序博客网 时间：2024/05/30 13:42

      ReentrantLock实现了标准的互斥操作，也就是说在某一时刻只有有一个线程持有锁。ReentrantLock采用这种独占的保守锁直接，在一定程度上减低了吞吐量。在这种情况下任何的“读/读”、“读/写”、“写/写”操作都不能同时发生。然而在实际的场景中我们就会遇到这种情况：有些资源并发的访问中，它大部分时间都是执行读操作，写操作比较少，但是读操作并不影响数据的一致性，如果在进行读操作时采用独占的锁机制，这样势必会大大降低吞吐量。所以如果能够做到读写分离，那就非常完美了。

ReadWriteLock， 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。对于ReadWriteLock而言，一个资源能够被多个读线程访问，或者被一个写线程访问，但是不能同时存在读写线程。也就是说读写锁使用的场合是一个共享资源被大量读取操作，而只有少量的写操作（修改数据）。如下：

[java] view plaincopyprint?
  1. public interface ReadWriteLock {  
  2.     Lock readLock();  
  3.     Lock writeLock();  
  4. }  

ReadWriteLock为一个接口，他定义了两个方法readLock、writeLock，从方法名我们就可以看出这两个方法是干嘛用的。ReentrantReadWriteLock作为ReadWriteLock的实现类，在API文档中详细介绍了它的特性。

(一) 公平性

      1)、 非公平锁（默认） 这个和独占锁的非公平性一样，由于读线程之间没有锁竞争，所以读操作没有公平性和非公平性，写操作时，由于写操作可能立即获取到锁，所以会推迟一个或多个读操作或者写操作。因此非公平锁的吞吐量要高于公平锁。

       2)、 公平锁 利用AQS的CLH队列，释放当前保持的锁（读锁或者写锁）时，优先为等待时间最长的那个写线程分配写入锁，当前前提是写线程的等待时间要比所有读线程的等待时间要长。同样一个线程持有写入锁或者有一个写线程已经在等待了，那么试图获取公平锁的（非重入）所有线程（包括读写线程）都将被阻塞，直到最先的写线程释放锁。如果读线程的等待时间比写线程的等待时间还有长，那么一旦上一个写线程释放锁，这一组读线程将获取锁。

(二) 重入性

      1)、 读写锁允许读线程和写线程按照请求锁的顺序重新获取读取锁或者写入锁。当然了只有写线程释放了锁，读线程才能获取重入锁。

      2)、 写线程获取写入锁后可以再次获取读取锁，但是读线程获取读取锁后却不能获取写入锁。

      3)、 另外读写锁最多支持65535个递归写入锁和65535个递归读取锁。(为何是65535后面介绍）

(三) 锁降级

      1)、 写线程获取写入锁后可以获取读取锁，然后释放写入锁，这样就从写入锁变成了读取锁，从而实现锁降级的特性。

(四) 锁升级

      1)、 读取锁是不能直接升级为写入锁的。因为获取一个写入锁需要释放所有读取锁，所以如果有两个读取锁视图获取写入锁而都不释放读取锁时就会发生死锁。

(五) 锁获取中断

      1)、 读取锁和写入锁都支持获取锁期间被中断。这个和独占锁一致。

(六) 条件变量

      1)、 写入锁提供了条件变量(Condition)的支持，这个和独占锁一致，但是读取锁却不允许获取条件变量，将得到一个UnsupportedOperationException异常。

(七) 重入数

      1)、 读取锁和写入锁的数量最大分别只能是65535（包括重入数）。

(八) 监测

      1)、 此类支持一些确定是保持锁还是争用锁的方法。这些方法设计用于监视系统状态，而不是同步控制。

ReentrantReadWriteLock与ReentrantLock一样，其锁主体依然是Sync，它的读锁、写锁都是依靠Sync来实现的。所以ReentrantReadWriteLock实际上只有一个锁，只是在获取读取锁和写入锁的方式上不一    样而已，它的读写锁其实就是两个类：ReadLock、writeLock，这两个类都是lock实现。

[java] view plaincopyprint?
  1. /** 读锁 */  
  2.     private final ReentrantReadWriteLock.ReadLock readerLock;  
  3.       
  4.     /** 写锁 */  
  5.     private final ReentrantReadWriteLock.WriteLock writerLock;  
  6.       
  7.       
  8.     final Sync sync;  
  9.   
  10.     /** 使用默认（非公平）的排序属性创建一个新的 ReentrantReadWriteLock */  
  11.     public ReentrantReadWriteLock() {  
  12.         this(false);  
  13.     }  
  14.   
  15.     /** 使用给定的公平策略创建一个新的 ReentrantReadWriteLock */  
  16.     public ReentrantReadWriteLock(boolean fair) {  
  17.         sync = fair ? new FairSync() : new NonfairSync();  
  18.         readerLock = new ReadLock(this);  
  19.         writerLock = new WriteLock(this);  
  20.     }  
  21.       
  22.     /** 返回用于写入操作的锁 */  
  23.     public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }  
  24.     /** 返回用于读取操作的锁 */  
  25.     public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }  
  26.       
  27.     public static class WriteLock implements Lock, java.io.Serializable{  
  28.         public void lock() {  
  29.             //独占锁  
  30.             sync.acquire(1);  
  31.         }  
  32.         /** 
  33.          * 省略其余源代码 
  34.          */  
  35.     }  
  36.       
  37.     public static class ReadLock implements Lock, java.io.Serializable {  
  38.         public void lock() {  
  39.             //共享锁  
  40.             sync.acquireShared(1);  
  41.         }  
  42.         /** 
  43.          * 省略其余源代码 
  44.          */  
  45.     }  

从上面的源代码我们可以看到WriteLock就是一个独占锁，readLock是一个共享锁，他们内部都是使用AQS的acquire、release来进行操作的。但是还是存在一些区别的。关于独占锁、共享锁，请关注前面的博客：

【Java并发编程实战】—–“J.U.C”：ReentrantLock之二lock方法分析

【Java并发编程实战】—–“J.U.C”：ReentrantLock之三unlock方法分析

【Java并发编程实战】—–“J.U.C”：Semaphore

下面LZ就ReadLock、WriteLock的获取锁（lock）、释放锁（release）进行分析。

WriteLock

lock()

                  

[java] view plaincopyprint?
  1. public void lock() {  
  2.         sync.acquire(1);  
  3.     }  

与ReentrantLock一样，调用AQS的acquire()：
[java] view plaincopyprint?
  1. public final void acquire(int arg) {  
  2.         if (!tryAcquire(arg) &&  
  3.             acquireQueued(addWaiter(Node.EXCLUSIVE), arg))  
  4.             selfInterrupt();  
  5.     }  

第一步，写锁调用tryAcquire方法，该方法与ReentrantLock中的tryAcquire方法略有不同：

[java] view plaincopyprint?
  1. protected final boolean tryAcquire(int acquires) {  
  2.         //当前线程  
  3.         Thread current = Thread.currentThread();  
  4.         //当前锁个数  
  5.         int c = getState();  
  6.         //写锁个数  
  7.         int w = exclusiveCount(c);  
  8.           
  9.         //当前锁个数 != 0（是否已经有线程持有锁），线程重入  
  10.         if (c != 0) {  
  11.             //w == 0,表示写线程数为0  
  12.             //或者独占锁不是当前线程，返回false  
  13.             if (w == 0 || current != getExclusiveOwnerThread())  
  14.                 return false;  
  15.               
  16.             //超出最大范围（65535）  
  17.             if (w + exclusiveCount(acquires) > MAX_COUNT)  
  18.                 throw new Error("Maximum lock count exceeded");  
  19.             //设置锁的线程数量  
  20.             setState(c + acquires);  
  21.             return true;  
  22.         }  
  23.           
  24.         //是否阻塞  
  25.         if (writerShouldBlock() ||  
  26.             !compareAndSetState(c, c + acquires))  
  27.             return false;  
  28.           
  29.         //设置锁为当前线程所有  
  30.         setExclusiveOwnerThread(current);  
  31.         return true;  
  32.     }  

在tryAcquire()中有一个段代码

int w = exclusiveCount(c);

该段代码主要是获取线程的数量的，在前面的特性里面有讲过读取锁和写入锁的数量最大分别只能是65535（包括重入数）。为何是65535呢？在前面LZ也提到过独占锁ReentrantLock中有一个state，共享锁中也有一个state，其中独占锁中的state为0或者1如果有重入，则表示重入的次数，共享锁中表示的持有锁的数量。而在ReadWriteLock中则不同，由于ReadWriteLock中存在两个锁，他们之间有联系但是也有差异，所以需要有两个state来分别表示他们。于是ReentrantReadWriteLock就将state一分二位，高16位表示共享锁的数量，低16位表示独占锁的数量。2^16 – 1 = 65535。这就是前面提过的为什么读取锁和写入锁的数量最大分别只能是65535。

[java] view plaincopyprint?
  1. ·   static final int SHARED_SHIFT   = 16;  
  2.     static final int SHARED_UNIT    = (1 << SHARED_SHIFT);  
  3.     static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;  
  4.     static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;  
  5.       
  6.     /** 返回共享锁持有线程的数量 **/  
  7.     static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }  
  8.     /** 返回独占锁持有线程的数量 **/  
  9.     static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }  

这段代码可以清晰表达计算写锁、读书持有线程的数量。

在上段tryAcquire方法的源代码中，主要流程如下：

1、首先获取c、w。然后判断是否已经有线程持有写锁（c != 0），如果持有，则线程进行重入。若w == 0（写入锁==0）或者 current != getExclusiveOwnerThread()（锁的持有者不是当前线程），则返回false。如果写入锁的数量超出最大范围（65535），则抛出error。

2、如果当且写线程数为0（那么读线程也应该为0，因为上面已经处理c!=0的情况），并且当前线程需要阻塞那么就返回失败；如果通过CAS增加写线程数失败也返回失败。

3、当c ==0或者c>0,w >0,则设置锁的持有则为当前线程。

unlock()

[java] view plaincopyprint?
  1. public void unlock() {  
  2.             sync.release(1);  
  3.         }  

unlock()调用Sync的release()：

[java] view plaincopyprint?
  1. public final boolean release(int arg) {  
  2.         if (tryRelease(arg)) {  
  3.             Node h = head;  
  4.             if (h != null && h.waitStatus != 0)  
  5.                 unparkSuccessor(h);  
  6.             return true;  
  7.         }  
  8.         return false;  
  9.     }  

在release()中首先调用tryRelease方法进行尝试释放锁：

[java] view plaincopyprint?
  1. protected final boolean tryRelease(int releases) {  
  2.         //若锁的持有者不是当前线程，抛出异常  
  3.         if (!isHeldExclusively())  
  4.             throw new IllegalMonitorStateException();  
  5.         //写锁的新线程数  
  6.         int nextc = getState() - releases;  
  7.         //若写锁的新线程数为0，则将锁的持有者设置为null  
  8.         boolean free = exclusiveCount(nextc) == 0;  
  9.         if (free)  
  10.             setExclusiveOwnerThread(null);  
  11.         //设置写锁的新线程数  
  12.         setState(nextc);  
  13.         return free;  
  14.     }  

写锁的释放过程还是相对而言比较简单的：首先查看当前线程是否为写锁的持有者，如果不是抛出异常。然后检查释放后写锁的线程数是否为0，如果为0则表示写锁空闲了，释放锁资源将锁的持有线程设置为null，否则释放仅仅只是一次重入锁而已，并不能将写锁的线程清空。

由于写锁与独占锁存在很大的相似之处，所以相同的地方，LZ不再阐述，更多请查阅：

【Java并发编程实战】—–“J.U.C”：ReentrantLock之二lock方法分析

【Java并发编程实战】—–“J.U.C”：ReentrantLock之三unlock方法分析

ReadLock

lock()

读锁的内在机制就是共享锁：

[html] view plaincopyprint?
  1. public void lock() {  
  2.             sync.acquireShared(1);  
  3.         }  

lock方法内部调用Sync的acquireShared()：

[java] view plaincopyprint?
  1. public final void acquireShared(int arg) {  
  2.         if (tryAcquireShared(arg) < 0)  
  3.             doAcquireShared(arg);  
  4.     }  

对于tryAquireShared():

[java] view plaincopyprint?
  1. protected final int tryAcquireShared(int unused) {  
  2.         Thread current = Thread.currentThread();  
  3.         //锁的持有线程数  
  4.         int c = getState();  
  5.         /* 
  6.          * 如果写锁线程数 != 0 ，且独占锁不是当前线程则返回失败，因为存在锁降级 
  7.          */  
  8.         if (exclusiveCount(c) != 0 &&  
  9.             getExclusiveOwnerThread() != current)  
  10.             return -1;  
  11.         //读锁线程数  
  12.         int r = sharedCount(c);  
  13.         /* 
  14.          * readerShouldBlock():读锁是否需要等待（公平锁原则） 
  15.          * r < MAX_COUNT：持有线程小于最大数（65535） 
  16.          * compareAndSetState(c, c + SHARED_UNIT)：设置读取锁状态 
  17.          */  
  18.         if (!readerShouldBlock() && r < MAX_COUNT &&  
  19.             compareAndSetState(c, c + SHARED_UNIT)) {  
  20.             /* 
  21.              * holdCount部分后面讲解 
  22.              */  
  23.             if (r == 0) {  
  24.                 firstReader = current;  
  25.                 firstReaderHoldCount = 1;  
  26.             } else if (firstReader == current) {  
  27.                 firstReaderHoldCount++;        //  
  28.             } else {  
  29.                 HoldCounter rh = cachedHoldCounter;  
  30.                 if (rh == null || rh.tid != current.getId())  
  31.                     cachedHoldCounter = rh = readHolds.get();  
  32.                 else if (rh.count == 0)  
  33.                     readHolds.set(rh);  
  34.                 rh.count++;  
  35.             }  
  36.             return 1;  
  37.         }  
  38.         return fullTryAcquireShared(current);  
  39.     }  

读锁获取锁的过程比写锁稍微复杂些：

1、写锁的线程数C！=0且写锁的线程持有者不是当前线程，返回-1。因为存在锁降级，写线程获取写入锁后可以获取读取锁。

2、依据公平性原则，判断读锁是否需要阻塞，读锁持有线程数小于最大值（65535），且设置锁状态成功，执行以下代码（对于HoldCounter下面再阐述），并返回1。如果不满足改条件，执行fullTryAcquireShared()：（HoldCounter部分后面讲解）

[java] view plaincopyprint?
  1. final int fullTryAcquireShared(Thread current) {  
  2.          HoldCounter rh = null;  
  3.          for (;;) {  
  4.              //锁的线程持有数  
  5.              int c = getState();  
  6.              //如果写锁的线程持有数 != 0 且锁的持有者不是当前线程，返回-1  
  7.              if (exclusiveCount(c) != 0) {  
  8.                  if (getExclusiveOwnerThread() != current)  
  9.                      return -1;  
  10.              }   
  11.              //若读锁需要阻塞  
  12.              else if (readerShouldBlock()) {  
  13.                  //若队列的头部是当前线程  
  14.                  if (firstReader == current) {  
  15.                  }   
  16.                  else {   //下面讲解  
  17.                      if (rh == null) {  
  18.                          rh = cachedHoldCounter;  
  19.                          if (rh == null || rh.tid != current.getId()) {  
  20.                              rh = readHolds.get();  
  21.                              if (rh.count == 0)  
  22.                                  readHolds.remove();  
  23.                          }  
  24.                      }  
  25.                      if (rh.count == 0)  
  26.                          return -1;  
  27.                  }  
  28.              }  
  29.              //读锁的线程数到达最大值：65536，抛出异常  
  30.              if (sharedCount(c) == MAX_COUNT)  
  31.                  throw new Error("Maximum lock count exceeded");  
  32.              //设置锁的状态成功  
  33.              if (compareAndSetState(c, c + SHARED_UNIT)) {  
  34.                  //  
  35.                  if (sharedCount(c) == 0) {  
  36.                      firstReader = current;  
  37.                      firstReaderHoldCount = 1;  
  38.                  }//  
  39.                  else if (firstReader == current) {  
  40.                      firstReaderHoldCount++;  
  41.                  }//下面讲解  
  42.                  else {  
  43.                      if (rh == null)  
  44.                          rh = cachedHoldCounter;  
  45.                      if (rh == null || rh.tid != current.getId())  
  46.                          rh = readHolds.get();  
  47.                      else if (rh.count == 0)  
  48.                          readHolds.set(rh);  
  49.                      rh.count++;  
  50.                      cachedHoldCounter = rh;  
  51.                  }  
  52.                  return 1;  
  53.              }  
  54.          }  
  55.      }  

unlock()

[java] view plaincopyprint?
  1. public  void unlock() {  
  2.             sync.releaseShared(1);  
  3.         }  

unlock调用releaseShared()方法，releaseShared()是AQS中的方法，如下：

[java] view plaincopyprint?
  1. public final boolean releaseShared(int arg) {  
  2.         if (tryReleaseShared(arg)) {  
  3.             doReleaseShared();  
  4.             return true;  
  5.         }  
  6.         return false;  
  7.     }  

tryReleaseShared是ReentrantReadWriteLock中的方法：

[java] view plaincopyprint?
  1. protected final boolean tryReleaseShared(int unused) {  
  2.         //当前线程  
  3.         Thread current = Thread.currentThread();  
  4.         /* 
  5.          * HoldCounter部分后面阐述 
  6.          */  
  7.         if (firstReader == current) {  
  8.             if (firstReaderHoldCount == 1)  
  9.                 firstReader = null;  
  10.             else  
  11.                 firstReaderHoldCount--;  
  12.         } else {  
  13.             HoldCounter rh = cachedHoldCounter;  
  14.             if (rh == null || rh.tid != current.getId())  
  15.                 rh = readHolds.get();  
  16.             int count = rh.count;  
  17.             if (count <= 1) {  
  18.                 readHolds.remove();  
  19.                 if (count <= 0)  
  20.                     throw unmatchedUnlockException();  
  21.             }  
  22.             --rh.count;  
  23.         }  
  24.         //不断循环，不断尝试CAS操作  
  25.         for (;;) {  
  26.             int c = getState();  
  27.             int nextc = c - SHARED_UNIT;  
  28.             if (compareAndSetState(c, nextc))  
  29.                 return nextc == 0;  
  30.         }  
  31.     }  

在这里同样忽略HoldCounter，其实在该方法中最关键的部分在于for(;;)部分，该部分其实就是一个不断尝试的CAS过程，直到修状态成功。

在读锁的获取、释放过程中，总是会有一个对象存在着，同时该对象在获取线程获取读锁是+1，释放读锁时-1，该对象就是HoldCounter。

HoldCounter

要明白HoldCounter就要先明白读锁。前面提过读锁的内在实现机制就是共享锁，对于共享锁其实我们可以稍微的认为它不是一个锁的概念，它更加像一个计数器的概念。一次共享锁操作就相当于一次计数器的操作，获取共享锁计数器+1，释放共享锁计数器-1。只有当线程获取共享锁后才能对共享锁进行释放、重入操作。所以HoldCounter的作用就是当前线程持有共享锁的数量，这个数量必须要与线程绑定在一起，否则操作其他线程锁就会抛出异常。

先看读锁获取锁的部分：

[java] view plaincopyprint?
  1. if (r == 0) {        //r == 0，表示第一个读锁线程，第一个读锁firstRead是不会加入到readHolds中  
  2.         firstReader = current;  
  3.         firstReaderHoldCount = 1;  
  4.     } else if (firstReader == current) {    //第一个读锁线程重入  
  5.         firstReaderHoldCount++;      
  6.     } else {    //非firstReader计数  
  7.         HoldCounter rh = cachedHoldCounter;        //readHoldCounter缓存  
  8.         //rh == null 或者 rh.tid != current.getId()，需要获取rh  
  9.         if (rh == null || rh.tid != current.getId())      
  10.             cachedHoldCounter = rh = readHolds.get();  
  11.         else if (rh.count == 0)  
  12.             readHolds.set(rh);        //加入到readHolds中  
  13.         rh.count++;        //计数+1  
  14.     }  

这里为什么要搞一个firstRead、firstReaderHoldCount呢？而不是直接使用else那段代码？这是为了一个效率问题，firstReader是不会放入到readHolds中的，如果读锁仅有一个的情况下就会避免查找readHolds。可能就看这个代码还不是很理解HoldCounter。我们先看firstReader、firstReaderHoldCount的定义：

[java] view plaincopyprint?
  1. private transient Thread firstReader = null;  
  2. private transient int firstReaderHoldCount;  

这两个变量比较简单，一个表示线程，当然该线程是一个特殊的线程，一个是firstReader的重入计数。

HoldCounter的定义：

[java] view plaincopyprint?
  1. static final class HoldCounter {  
  2.             int count = 0;  
  3.             final long tid = Thread.currentThread().getId();  
  4.         }  

在HoldCounter中仅有count和tid两个变量，其中count代表着计数器，tid是线程的id。但是如果要将一个对象和线程绑定起来仅记录tid肯定不够的，而且HoldCounter根本不能起到绑定对象的作用，只是记录线程tid而已。

诚然，在java中，我们知道如果要将一个线程和对象绑定在一起只有ThreadLocal才能实现。所以如下：

[html] view plaincopyprint?
  1. static final class ThreadLocalHoldCounter  
  2.             extends ThreadLocal<HoldCounter> {  
  3.             public HoldCounter initialValue() {  
  4.                 return new HoldCounter();  
  5.             }  
  6.         }  
ThreadLocalHoldCounter继承ThreadLocal，并且重写了initialValue方法。

故而，HoldCounter应该就是绑定线程上的一个计数器，而ThradLocalHoldCounter则是线程绑定的ThreadLocal。从上面我们可以看到ThreadLocal将HoldCounter绑定到当前线程上，同时HoldCounter也持有线程Id，这样在释放锁的时候才能知道ReadWriteLock里面缓存的上一个读取线程（cachedHoldCounter）是否是当前线程。这样做的好处是可以减少ThreadLocal.get()的次数，因为这也是一个耗时操作。需要说明的是这样HoldCounter绑定线程id而不绑定线程对象的原因是避免HoldCounter和ThreadLocal互相绑定而GC难以释放它们（尽管GC能够智能的发现这种引用而回收它们，但是这需要一定的代价），所以其实这样做只是为了帮助GC快速回收对象而已（引自[1]）。

示例

[java] view plaincopyprint?
  1. public class Reader implements Runnable{  
  2.       
  3.     private PricesInfo pricesInfo;  
  4.       
  5.     public Reader(PricesInfo pricesInfo){  
  6.         this.pricesInfo = pricesInfo;  
  7.     }  
  8.   
  9.     @Override  
  10.     public void run() {  
  11.         for (int i = 0; i < 10; i++) {  
  12.             System.out.println(Thread.currentThread().getName() + "--Price 1:" + pricesInfo.getPrice1());  
  13.             System.out.println(Thread.currentThread().getName() + "--Price 1:" + pricesInfo.getPrice2());  
  14.         }  
  15.     }  
  16.   
  17. }  

Writer

[java] view plaincopyprint?
  1. public class Writer implements Runnable{  
  2.     private PricesInfo pricesInfo;  
  3.   
  4.     public Writer(PricesInfo pricesInfo){  
  5.         this.pricesInfo = pricesInfo;  
  6.     }  
  7.       
  8.     @Override  
  9.     public void run() {  
  10.         for (int i=0; i<3; i++) {  
  11.             System.out.printf("Writer: Attempt to modify the prices.\n");  
  12.             pricesInfo.setPrices(Math.random()*10, Math.random()*8);  
  13.             System.out.printf("Writer: Prices have been modified.\n");  
  14.             try {  
  15.                 Thread.sleep(2);  
  16.             } catch (InterruptedException e) {  
  17.                 e.printStackTrace();  
  18.             }  
  19.         }  
  20.           
  21.     }  
  22. }  

PriceInfo

[java] view plaincopyprint?
  1. public class PricesInfo {  
  2.     private double price1;  
  3.     private double price2;  
  4.       
  5.     private ReadWriteLock  lock;  
  6.       
  7.     public PricesInfo(){  
  8.         price1 = 1.0;  
  9.         price2 = 2.0;  
  10.           
  11.         lock = new ReentrantReadWriteLock();  
  12.     }  
  13.       
  14.     public double getPrice1(){  
  15.         lock.readLock().lock();  
  16.         double value = price1;  
  17.         lock.readLock().unlock();  
  18.         return value;  
  19.     }  
  20.       
  21.     public double getPrice2(){  
  22.         lock.readLock().lock();  
  23.         double value = price2;  
  24.         lock.readLock().unlock();  
  25.         return value;  
  26.     }  
  27.       
  28.     public void setPrices(double price1, double price2){  
  29.         lock.writeLock().lock();   
  30.         this.price1 = price1;  
  31.         this.price2 = price2;  
  32.         lock.writeLock().unlock();  
  33.     }  
  34. }  

Test：

[java] view plaincopyprint?
  1. public class Test {  
  2.     public static void main(String[] args) {  
  3.         PricesInfo pricesInfo = new PricesInfo();  
  4.           
  5.         Reader[] readers = new Reader[5];  
  6.         Thread[] readerThread = new Thread[5];  
  7.         for (int i=0; i<5; i++){  
  8.             readers[i]=new Reader(pricesInfo);  
  9.             readerThread[i]=new Thread(readers[i]);  
  10.         }  
  11.           
  12.         Writer writer=new Writer(pricesInfo);  
  13.         Thread threadWriter=new Thread(writer);  
  14.           
  15.         for (int i=0; i<5; i++){  
  16.             readerThread[i].start();  
  17.         }  
  18.         threadWriter.start();  
  19.     }  
  20. }  

参考资料：

1、Java多线程（十）之ReentrantReadWriteLock深入分析

2、JUC 可重入 读写锁 ReentrantReadWriteLock

0 0
2016知乎日报启动画面 2016知乎日报启动画面
原创粉丝点击
热门IT博客
linux vi删除字符linux vi删除字符
淘宝网内衣专卖淘宝网内衣专卖
2017上半年进出口数据
数组属于一种原生类
linux tmp 清理
淘宝爆款计划表
阿里云到底是干嘛的
数控铣床编程熊图案
单片机按键程序
知乎女神王麟
手机载图软件
人机围棋软件
自动更换ip软件
kms10激活软件是什么
淘宝企业代办
想找个网络兼职
qq美化主题软件
知乎 用户状态异常
黑色沙漠召唤数据
文学少女知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 维尚集团维意定制家具 维意定制家具沙发 维意定制家具软件 维意定制家具图片 维意定制家具logo 维意定制家具价格高吗 尚品宅配维意 维意定制和尚品宅配 维意 尚品宅配 维意定制家具地址 维意定制家具的效果图 维意招聘 尚品宅配 维意 维意家具定制怎么样 维意家具定制价格 维意与尚品宅配哪个好 维意定制家具环保吗 维意定制家具品牌 维意定制家具招聘 避轻松依维意抗菌剂 依维意纳米抗菌凝露 尚品宅配和维意定制 唯白晶焕深层修护面膜 唯上智与下愚不移 金唯智 金唯智生物科技有限公司 唯有杜康 唯有读书高 唯有自渡 唯有你 唯有魔力 唯有的意思 唯有 唯有牡丹真国色 何以解忧唯有杜康 唯有美食不可辜负 何以解忧唯有暴富 万般皆下品唯有读书高 唯有美食不可辜负前一句 此生风月唯有你 唯有饮者留其名

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里