ReentrantReadWriteLock的使用
ReentrantReadWriteLock是JDK提供的读写锁机制，写锁是排他锁，读锁是共享锁。
//创建一个读写锁
ReentrantReadWriteLock reentrantLock = new ReentrantReadWriteLock();
//根据读写锁对象分别创建写锁和读锁
Lock w = reentrantLock.writeLock();
Lock r = reentrantLock.readLock();
ReentrantReadWriteLock把AQS表示锁状态的字段state逻辑上分为了两个部分：高16位是同一个锁被获取共享锁（读锁）的次数，低16位是同一个锁被获取排他锁（写锁）的次数。
默认情况下，创建ReentrantReadWriteLock对象也是按照非公平策略:
public ReentrantReadWriteLock(boolean fair) {
//sync 的实现与ReentrantLock一样
sync = fair ? new FairSync() : new NonfairSync();
readerLock = new ReadLock(this);
writerLock = new WriteLock(this);
}
由下面代码可以知道，ReadLock和WriteLock使用的相同的sync变量:
readerLock = new ReadLock(this);
writerLock = new WriteLock(this);
protected WriteLock(ReentrantReadWriteLock lock) {
sync = lock.sync;
}
protected ReadLock(ReentrantReadWriteLock lock) {
sync = lock.sync;
}
写锁加锁
执行写锁w.lock()方法，来获取写锁，w.lock方法的实现最终会调用Sync类的tryAcquire方法
写锁的tryAcquire方法实现如下：
protected final boolean tryAcquire(int acquires) {
Thread current = Thread.currentThread();
//获取锁状态
int c = getState();
//获取排他锁的个数，也就是写锁的个数
int w = exclusiveCount(c);
//锁状态个数不为0，且写锁为0或者持有锁的线程不是当前线程，那么失败
if (c != 0) {
// (Note: if c != 0 and w == 0 then shared count != 0)
if (w == 0 || current != getExclusiveOwnerThread())
return false;
if (w + exclusiveCount(acquires) > MAX_COUNT)
throw new Error("Maximum lock count exceeded");
// 如果是当前线程之前已经获取该锁
setState(c + acquires);
return true;
}
if (writerShouldBlock() ||
!compareAndSetState(c, c + acquires))
return false;
setExclusiveOwnerThread(current);
return true;
}
主要逻辑：
1.判断锁状态
2.计算获取写锁的次数
(1)当前锁状态为0，执行 (2)，否则执行下面
a 如果当前锁状态是读锁或者 b当前锁状态是写锁，但是持有锁的线程不是当前线程，那么获取失败，返回false
(2)设置锁的装状态，如果成功这设置获取锁的线程为当前线程，返回true。否则获取锁失败，返回false
如果写锁的tryAcquire方法返回true
那么会把当前线程封装为一个Node节点对象，把该node节点对象加入AQS的阻塞队列中。
写锁释放
写锁的释放，会调用ReentrantReadWriteLock内部静态类Sync的tryRelease方法，下面是tryRelease具体实现：
protected final boolean tryRelease(int releases) {
//判断当前申请释放锁的线程是不是持有锁的线程
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
int nextc = getState() - releases;
//判断排它锁值状态是不是0
boolean free = exclusiveCount(nextc) == 0;
if (free)
setExclusiveOwnerThread(null);
setState(nextc);
return free;
}
当tryRelease返回true之后，此时没有线程持有锁，接着就可以从AQS的阻塞队列中释放一个线程去执行：
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h); //从阻塞对列中获取一个线程
return true;
}
return false;
}
读锁获取
读锁也被称为共享锁，获取共享锁的方法tryAcquireShared实现如下
protected final int tryAcquireShared(int unused) {
Thread current = Thread.currentThread();
int c = getState();
//排它锁不等于0并且拥有排他锁的线程不是当前线程，那么返回-1
if (exclusiveCount(c) != 0 &&
getExclusiveOwnerThread() != current)
return -1;
//获取共享锁数量
int r = sharedCount(c);
//这里有个readerShouldBlock()是为了避免在非公平策略下写锁一直处于饥饿状态，
//readerShouldBlock实现主要是判断如果当阻塞队列的第一个等待锁的线程是写操作
//那么就要阻塞当前读线程，使得让写线程能有机会获取到写锁
if (!readerShouldBlock() &&
r < MAX_COUNT &&
compareAndSetState(c, c + SHARED_UNIT)) {
if (r == 0) {
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
//如果当前锁是读锁，但是持有锁的线程不是当前线程，执行下面的操作
//给获取一个存储在ThreadLocal对象中的缓存对象HoldCounter，该值主要是存储
//每个线程获取读锁的个数
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
cachedHoldCounter = rh = readHolds.get();//readHolds 是Threadlocal对象
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
}
return 1;
}
//下面的方法是处理CAS失败或者是在tryAcquireShared没有处理的重入读锁
return fullTryAcquireShared(current);
}
线程从tryAcquireShared方法中返回大于0表示成功获取到共享锁，如果返回小于0表示获取共享锁失败，那么就需要执行doAcquireShared()方法，把当前线程加入到等待队列中。
读锁释放
读锁释放的主要逻辑:
1.判断获取读锁的第一个线程是不是当前线程，如果是修改锁数量，然后执行3，如果不是当前线程，执行2
2.获取当前线程自己的HoldCounter 对象，修改HoldCounter 中读锁数量值，执行3
3.使用CAS修改AQS的锁状态信息，并返回AQS的缩状态
protected final boolean tryReleaseShared(int unused) {
Thread current = Thread.currentThread();
if (firstReader == current) {
// assert firstReaderHoldCount > 0;
if (firstReaderHoldCount == 1)
firstReader = null;
else
firstReaderHoldCount--;
} else {
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
rh = readHolds.get();
int count = rh.count;
if (count <= 1) {
readHolds.remove();
if (count <= 0)
throw unmatchedUnlockException();
}
--rh.count;
}
for (;;) {
int c = getState();
int nextc = c - SHARED_UNIT;
if (compareAndSetState(c, nextc))
// Releasing the read lock has no effect on readers,
// but it may allow waiting writers to proceed if
// both read and write locks are now free.
return nextc == 0;
}
}
