以前分析过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双向链表的尾部,等待一个一个获取锁资源。