Java的ReadWriteLock实现机制解析(2)

上一篇说到了WriterPreferenceReadWriteLock，这一篇说一下ReentrantWriterPreferenceReadWriteLock。  

      顾名思义，该类实现的是可重入的的WriterPreferenceReadWriteLock。允许readers和writers在各自线程里反复获得读或写的锁。这种方法主要用在

      该类是WriterPreferenceReadWriteLock的子类，与父类大体流程一致，但是startWrite，startRead ，allowReader ，endRead和endWrite被重写，下面逐一解释。  

    先看看新添加的成员变量

 

 

Java代码  

1. /**在activeWriter线程里，有多少次write锁的控制权被获取**/       
2. protected long writeHolds_ = 0;     
3.   
4.  /**存放的每个reader线程共申请获得多少次读控制,key值是thread对象，value是次数**/  
5. protected HashMap readers_ = new HashMap();   
6.   
7. /*一个int的常量缓存*/  
8. protected static final Integer IONE = new Integer(1);  

/**在activeWriter线程里，有多少次write锁的控制权被获取**/	
protected long writeHolds_ = 0;  

 /**存放的每个reader线程共申请获得多少次读控制,key值是thread对象，value是次数**/
protected HashMap readers_ = new HashMap();

/*一个int的常量缓存*/
protected static final Integer IONE = new Integer(1);

 

   再来看看Reader部分的重写函数

 

Java代码  

1. protected boolean allowReader() {   
2.     //与父类的变化在于,activeWriter_ == Thread.currentThread(),   
3.     //也就是说当本线程已经获得写控制的时候，返回true   
4.     return (activeWriter_ == null && waitingWriters_ == 0) ||   
5.         activeWriter_ == Thread.currentThread();   
6. }   
7.   
8. protected synchronized boolean startRead() {   
9.     Thread t = Thread.currentThread();   
10.     //查看本线程是否已经获得读控制   
11.     Object c = readers_.get(t);   
12.     if (c != null) { // already held -- just increment hold count   
13.         //计数+1   
14.         readers_.put(t, new Integer(((Integer)(c)).intValue()+1));   
15.         ++activeReaders_;   
16.         return true;   
17.     }   
18.     //调用allowReader   
19.     else if (allowReader()) {   
20.         //将本线程获锁次数纪录在readers_这个map里   
21.         readers_.put(t, IONE);   
22.         ++activeReaders_;   
23.         return true;   
24.     }   
25.     else  
26.         return false;   
27. }   
28.   
29.   
30. protected synchronized Signaller endRead() {   
31.     Thread t = Thread.currentThread();   
32.     Object c = readers_.get(t);   
33.     if (c == null)   
34.         throw new IllegalStateException();   
35.     --activeReaders_;   
36.     if (c != IONE) { // 多于一个读线程有控制权，more than one hold; 计数递减   
37.         int h = ((Integer)(c)).intValue()-1;   
38.         Integer ih = (h == 1)? IONE : new Integer(h);   
39.         readers_.put(t, ih);   
40.         return null;   
41.     }   
42.     else {   
43.         readers_.remove(t);   
44.   
45.         if (writeHolds_ > 0) // 本线程还有写锁在占用控制权   
46.             return null;   
47.         //其余与父类实现一样   
48.         else if (activeReaders_ == 0 && waitingWriters_ > 0)   
49.             return writerLock_;   
50.         else  
51.             return null;   
52.     }   
53. }  

protected boolean allowReader() {
    //与父类的变化在于,activeWriter_ == Thread.currentThread(),
    //也就是说当本线程已经获得写控制的时候，返回true
    return (activeWriter_ == null && waitingWriters_ == 0) ||
        activeWriter_ == Thread.currentThread();
}

protected synchronized boolean startRead() {
    Thread t = Thread.currentThread();
    //查看本线程是否已经获得读控制
    Object c = readers_.get(t);
    if (c != null) { // already held -- just increment hold count
        //计数+1
        readers_.put(t, new Integer(((Integer)(c)).intValue()+1));
        ++activeReaders_;
        return true;
    }
    //调用allowReader
    else if (allowReader()) {
        //将本线程获锁次数纪录在readers_这个map里
        readers_.put(t, IONE);
        ++activeReaders_;
        return true;
    }
    else
        return false;
}


protected synchronized Signaller endRead() {
    Thread t = Thread.currentThread();
    Object c = readers_.get(t);
    if (c == null)
        throw new IllegalStateException();
    --activeReaders_;
    if (c != IONE) { // 多于一个读线程有控制权，more than one hold; 计数递减
        int h = ((Integer)(c)).intValue()-1;
        Integer ih = (h == 1)? IONE : new Integer(h);
        readers_.put(t, ih);
        return null;
    }
    else {
        readers_.remove(t);

        if (writeHolds_ > 0) // 本线程还有写锁在占用控制权
            return null;
        //其余与父类实现一样
        else if (activeReaders_ == 0 && waitingWriters_ > 0)
            return writerLock_;
        else
            return null;
    }
}

 

    Reader部分相对于父类的变化在于

    * 每个reader试图竞争控制权时，都会将本线程句柄与activeWriter进行比较，相同则认为是可以重入。

    * 每个reader线程都在readers_的map里有一个计数器，判断当前有多少次获得reader锁权，释放的时候，只有当计数器为0时才通知其他写线程结束wait。

 

  

  接着看看Writer部分的重写函数

 

Java代码  

1. protected synchronized boolean startWrite() {   
2.     if (activeWriter_ == Thread.currentThread()) { // 反复重入         
3.         ++writeHolds_;   
4.         return true;   
5.     }   
6.     else if (writeHolds_ == 0) {   
7.         //如果没有人在读(activeReaders_==0)和，或者在读的线程和本线程一样，并且readers里没有其他线程   
8.         if (activeReaders_ == 0 ||    
9.                 (readers_.size() == 1 &&    
10.                  readers_.get(Thread.currentThread()) != null)) {   
11.             //如果本线程在读中，则也可以进入writeLock   
12.             activeWriter_ = Thread.currentThread();   
13.             writeHolds_ = 1;   
14.             return true;   
15.         }   
16.         else  
17.             return false;   
18.     }   
19.     else  
20.         return false;   
21. }   
22.   
23.   
24. protected synchronized Signaller endWrite() {   
25.     --writeHolds_;   
26.     if (writeHolds_ > 0)     
27.         //这是主要与父类不一样的地方，写锁计数标示仍然有写锁没有被释放   
28.         return null;   
29.     else {   
30.         //与父类一致        
31.         activeWriter_ = null;   
32.         if (waitingReaders_ > 0 && allowReader())   
33.             return readerLock_;   
34.         else if (waitingWriters_ > 0)   
35.             return writerLock_;   
36.         else  
37.             return null;   
38.     }   
39. }  

protected synchronized boolean startWrite() {
    if (activeWriter_ == Thread.currentThread()) { // 反复重入    	
        ++writeHolds_;
        return true;
    }
    else if (writeHolds_ == 0) {
        //如果没有人在读(activeReaders_==0)和，或者在读的线程和本线程一样，并且readers里没有其他线程
        if (activeReaders_ == 0 || 
                (readers_.size() == 1 && 
                 readers_.get(Thread.currentThread()) != null)) {
            //如果本线程在读中，则也可以进入writeLock
            activeWriter_ = Thread.currentThread();
            writeHolds_ = 1;
            return true;
        }
        else
            return false;
    }
    else
        return false;
}


protected synchronized Signaller endWrite() {
    --writeHolds_;
    if (writeHolds_ > 0)  
        //这是主要与父类不一样的地方，写锁计数标示仍然有写锁没有被释放
        return null;
    else {
        //与父类一致    	
        activeWriter_ = null;
        if (waitingReaders_ > 0 && allowReader())
            return readerLock_;
        else if (waitingWriters_ > 0)
            return writerLock_;
        else
            return null;
    }
}

 

   Writer主要与父类不同的地方是

   * 通过writeHolds来记录本线程获得锁的次数，以便在release时正确调用通知机制

   * 通过当前线程和activeWriter线程比较来实现重入

 

1.3 EDU.oswego.cs.dl.util.concurrent.ReaderPreferenceReadWriteLock

 

  ReaderPreferenceReadWriteLock类和父类唯一不同就是allowReader方法

Java代码  

1. protected boolean allowReader() {   
2.     //只要没有写，就允许读   
3.     return activeWriter_ == null;   
4. }  

protected boolean allowReader() {
    //只要没有写，就允许读
    return activeWriter_ == null;
}

   这个类在大多数场景下都不太实用，多数人主要还是使用writer优先锁。