JAVA并发编程学习笔记之ReentrantLock

ReentrantLock是一个可重入的互斥锁，ReentrantLock由最近成功获取锁，还没有释放的线程所拥有，当锁被另一个线程拥有时，调用lock的线程可以成功获取锁。如果锁已经被当前线程拥有，当前线程会立即返回。此类的构造方法提供一个可选的公平参数

[html]   view plain copy print ?

1. public ReentrantLock(boolean fair) {  
2.     sync = fair ? new FairSync() : new NonfairSync();  
3. }  

公平与非公平有何区别，所谓公平就是严格按照FIFO顺序获取锁，非公平安全由程序员自己设计，比如可以按优先级，也可以按运行次数等规则来选择。

在AQS里面有一个state字段，在ReentrantLock中表示锁被持有的次数，它是一个volatile类型的整型值，因此对它的修改可以保证其他线程可以看到。ReentrantLock顾名思义就是锁可以重入，一个线程持有锁，state=1,如果它再次调用lock方法，那么他将继续拥有这把锁，state=2.当前可重入锁要完全释放，调用了多少次lock方法，还得调用等量的unlock方法来完全释放锁。下面简单看一下它的获取与释放过程：

ReentrantLock实现了Lock接口，获取锁是通过lock方法来实现的，整个过程和AQS的获取过程一样，这里不再分析，只分析它的tryAcquire方法的实现。tryAcquire方法有公平版本与非公平版权，源于ReentrantLock使用了两种同步器，具体使用哪一个是在构造方法中提供的公平参数。先看看公平版本的tryAcquire方法：

[java]   view plain copy print ?

1. /** 
2.  * Fair version of tryAcquire.  Don't grant access unless 
3.  * recursive call or no waiters or is first. 
4.  */  
5. protected final boolean tryAcquire(int acquires) {  
6.     final Thread current = Thread.currentThread();  
7.     int c = getState();  
8.     if (c == 0) {  
9.         if (!hasQueuedPredecessors() &&  
10.             compareAndSetState(0, acquires)) {  
11.             setExclusiveOwnerThread(current);  
12.             return true;  
13.         }  
14.     }  
15.     else if (current == getExclusiveOwnerThread()) {  
16.         int nextc = c + acquires;  
17.         if (nextc < 0)  
18.             throw new Error("Maximum lock count exceeded");  
19.         setState(nextc);  
20.         return true;  
21.     }  
22.     return false;  
23. }  

1、首先判断锁有没有被持有，如果被持有，就判断持有锁的线程是不是当前线程，如果不是就啥也不做，返回获取失败，如果是就增加重入数，返回成功获取；

2、如果锁没有被任何线程持有（c==0），首先判断当前结点前面是否还有线程在排除等待锁，如果有，直接返回获取失败，否则将锁持有数设为acquires，一般为1，然后设置锁的拥有者为当前线程，成功获取。

整个过程比较简单，再来看看非公平的tryAcquire方法：

[java]   view plain copy print ?

1. /** 
2.  * Performs non-fair tryLock.  tryAcquire is 
3.  * implemented in subclasses, but both need nonfair 
4.  * try for trylock method. 
5.  */  
6. final boolean nonfairTryAcquire(int acquires) {  
7.     final Thread current = Thread.currentThread();  
8.     int c = getState();  
9.     if (c == 0) {  
10.         if (compareAndSetState(0, acquires)) {  
11.             setExclusiveOwnerThread(current);  
12.             return true;  
13.         }  
14.     }  
15.     else if (current == getExclusiveOwnerThread()) {  
16.         int nextc = c + acquires;  
17.         if (nextc < 0) // overflow  
18.             throw new Error("Maximum lock count exceeded");  
19.         setState(nextc);  
20.         return true;  
21.     }  
22.     return false;  
23. }  

代码几乎一模一样，唯一不同的是在知道锁持有数为0时，直接将当前线程设置为锁的持有者，这一点和公平版本的tryAcquire是有区别的，也就是说非公平机制采用的是抢占式模型。

看完了锁的获取，再来看锁的释放，锁的释放就不存在公平与非公平一说。

[java]   view plain copy print ?

1. protected final boolean tryRelease(int releases) {  
2.     int c = getState() - releases;  
3.     if (Thread.currentThread() != getExclusiveOwnerThread())  
4.         throw new IllegalMonitorStateException();  
5.     boolean free = false;  
6.     if (c == 0) {  
7.         free = true;  
8.         setExclusiveOwnerThread(null);  
9.     }  
10.     setState(c);  
11.     return free;  
12. }  

1、首先判断当前线程是不是拥有锁的线程，如果不是，抛出IllegalMonitorStateException异常，这个异常表明表明某一线程已经试图等待对象的监视器，或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程；

2、判断释放之后的锁持有数c，如果c!=0，先设置state为该值，然后返回false表示没有被完全释放。如果c==0，表示锁被完全释放，当前线程释放对锁的拥有，返回true,表示已完全释放。

此外ReentrantLock还有一些其他方法，但大部分都是直接代理了AQS中的方法，顺便提一下，可以使用isHeldByCurrentThread() 和 getHoldCount()方法来检查当前线程是否拥有该锁

[java]   view plain copy print ?

1. final int getHoldCount() {  
2.     return isHeldExclusively() ? getState() : 0;  
3. }  
4.   
5. public boolean isHeldByCurrentThread() {  
6.     return sync.isHeldExclusively();  
7. }  
8.   
9. protected final boolean isHeldExclusively() {  
10.     return getExclusiveOwnerThread() == Thread.currentThread();  
11. }  

JDK文档还提到，可以将isHeldExclusively用于调试和测试，例如，只在保持某个锁时才应调用的方法可以声明如下：

[java]   view plain copy print ?

1. class X {  
2.   ReentrantLock lock = new ReentrantLock();  
3.   // ...  
4.   
5.   public void m() {   
6.       assert lock.isHeldByCurrentThread();  
7.       // ... method body  
8.   }  
9. }  

还可以用此方法来确保某个重入锁是否以非重入方式使用的，例如：

[java]   view plain copy print ?

1. class X {  
2.   ReentrantLock lock = new ReentrantLock();  
3.   // ...  
4.   
5.   public void m() {   
6.       assert !lock.isHeldByCurrentThread();  
7.       lock.lock();  
8.       try {  
9.           // ... method body  
10.       } finally {  
11.           lock.unlock();  
12.       }  
13.   }  
14. }  

参考资料：

JDK文档：ReentrantLock

Java 理论与实践: JDK 5.0 中更灵活、更具可伸缩性的锁定机制