以前分析过AQS的源码以及线程池和堵塞队列源码的时候，其实看过这个这个源码的，但是总是会忘，故分析一下，记录下来。
有了前面的基础，其实ReentrantReadWriteLock源码相对比较简单。
ReentrantReadWriteLock的使用，大概是，
reentrantReadWriteLock.readLock().lock();
reentrantReadWriteLock.writerLock().lock();
也就是，读锁和写锁，读读不互斥，写和任何锁互斥。
构造方法
可以看到维护了两把锁，一把读锁，一把写锁
public ReentrantReadWriteLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
readerLock = new ReadLock(this);
writerLock = new WriteLock(this);
}
可以看到sync实现了AQS
abstract static class Sync extends AbstractQueuedSynchronizer {
看它的lock方法，调用的是sync的lock，如果是默认的构造方法，则调用的是非公平锁的lock方法。
public void lock() {
sync.lock();
}
非公平锁的lock方法
final void lock() {
// 直接争取锁资源，不管队列有没有元素
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 直接争取锁资源，不管队列有没有元素
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 如果state不为0，则说明这个线程已经获得锁了，这里只是再获取一次，则只是把state + 1，也就是加 acquires
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
公平锁的lock方法
对比非公平锁的lock方法，可以看到，非公平锁，会直接去cas争取state，也就是直接争取锁的资源，公平锁，则会去看队列中有没有元素，没有才，获取锁，有，则进入队列，也就是有公平顺序的。
final void lock() {
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 公平锁会看一下队列有没有元素，有，则按先后顺序，自己进入队列
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
释放锁：也就是释放资源，许可证-1，也就是lock了几次，就要unlock几次。
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
// 尝试释放资源
if (tryRelease(arg)) {
// 释放成功，则唤醒AQS的双向node链表的头部节点
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
至于一些acquire方法的尝试获取锁和入队等AQS的操作，不再细讲，可以看之前的AQS源码分析。
还有一个常用的操作是:
Condition condition = reantrantLock.newCondition();
condition.await();
condtion.signal();
实现类似object的wait和signal的功能。
这个condition是一个接口，conditionObject是它的实现类，condition是AQS维护的内部类，关于它的原理，前面AQS的源码有分析，这里摘抄一下大概原理：
调用condition.await()方法，意味着当前线程进入等待状态。将当前节点包装成node节点，放入condition链表的尾部。然后调用AQS的release方法，释放state，locksupport.unpack()双向node链表的头结点线程。之后，再将自身线程堵塞。
signal方法总结：调用condition.signal()方法，意味着唤醒其他线程调用condition.await()方法进入等待状态的线程。会将conditionObject维护的node单向链表的头节点（也就是第一个调用condition.await的线程节点），移动到AQS维护的双向node节点的尾部，等待其他线程使用完资源后调用release方法一个一个唤醒。
public Condition newCondition() {
return sync.newCondition();
}
final ConditionObject newCondition() {
return new ConditionObject();
}
总结：公平锁和非公平锁，的区别就是，非公平锁不管AQS维护的双向链表队列有没有元素，直接cas获取state，获取资源许可证。而公平锁则会看队列是否元素，有则放到队列尾部，按顺序获取资源锁。
reentrantlock的lock一次，则AQs的state则+1，lock一次则加-，unlock一次，则减1，也就是lock了几次，就要unlock几次。
reentrantlock的new Condition方法，新建的就是AQS的conditionObject，await一下，则把线程node放入conditionobject维护的单向链表，signal一次，则把conditionObject维护的单链表的头部节点，转入AQS双向链表的尾部，等待一个一个获取锁资源。
网友评论