一、独占锁ReentrantLock的原理
类图结构
- ReentrantLock使用AQS实现，根据参数决定其内部是否为公平锁，默认是非公平锁。Sync类直接继承自AQS，子类NonfairSync和FairSync分别实现了获取锁的非公平与公平策略
- 这里的state表示线程获取该锁的可重入次数
获取锁
- void lock()方法
public void lock() {
sync.lock();
}
先看sync的子类NonfairSync（非公平锁）
final void lock() {
// CAS设置状态值
if (compareAndSetState(0, 1))
// 设置该锁的持有者是当前线程
setExclusiveOwnerThread(Thread.currentThread());
else
// 调用AQS的acquire方法，会调用tryAcquire方法
acquire(1);
}
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
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;
}
非公平锁采用的是抢占策略：线程A先获取锁失败后会被放入AQS阻塞队列，若此时线程B也获取锁并且锁刚被释放，则获取成功（明明A先申请的，结果却是B先获取到，这就是非公平）
再看看公平锁FairSync怎么实现的
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;
}
public final boolean hasQueuedPredecessors() {
Node t = tail;
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}
公平锁在当前线程可以获取锁的时候遍历AQS阻塞队列，将锁让给之前的线程
- void lockInterruptibly()方法
与lock类似，会对interrupt方法做出响应
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
public final void acquireInterruptibly(int arg) throws InterruptedException {
// 如果当前线程被中断，则直接抛出异常
if (Thread.interrupted())
throw new InterruptedException();
// 尝试获取资源
if (!tryAcquire(arg))
// 调用AQS可被中断的方法
doAcquireInterruptibly(arg);
}
-
boolean tryLock()方法：尝试获取锁
-
boolean tryLock(long timeout,TimeUnit unit)方法： 尝试获取锁，设置了超时时间
public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
// 调用AQS的tryAcquireNanos
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
释放锁
- void unlock()方法
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
if (tryRelease(arg)) {
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;
// 若当前可重入次数为0，则清空锁持有线程
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
二、读写锁ReentrantReadWriteLock的原理
解决线程安全问题使用ReentrantLock就可以，但是ReentrantLock是独占锁，某时只有一个线程可以获取该锁，而实际中会有写少读多的场景，显然ReentrantLock满足不了这个需求，所以ReentrantReadWriteLock应运而生。其采用的是读写分离的策略，允许多个线程同时获取读锁。
类图结构
读写锁内部维护了一个ReadLock和一个WriteLock。下面只介绍非公平的读写锁实现，读写锁state的高16位表示读状态，也就是获取到读锁的次数；低16位表示获取到写锁的线程的可重入次数。
static final int SHARED_SHIFT = 16;
// 共享锁（读锁）状态单位值65536
static final int SHARED_UNIT = (1 << SHARED_SHIFT);
// 共享锁线程最大个数65536
static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1;
// 排他锁（写锁）掩码，二进制，15个1
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
// 返回读锁线程数
static int sharedCount(int c) { return c >>> SHARED_SHIFT; }
// 返回写锁可重入个数
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }
- firstReader()：记录第一个获取到读锁的线程
- firstReaderHoldCount()：记录idyige获取到读锁的线程获取读锁的可重入次数
- cacheHoldCounter()：记录最后一个获取读锁的线程获取读锁的可重入次数
- readHolds：Thread变量，存放除去第一个获取读锁线程外的其他线程获取读锁的可重入次数
- ThreadLocalHoldCounter：继承ThreadLocal。initialValue()返回一个HoldCounter对象
static final class ThreadLocalHoldCounter extends ThreadLocal<HoldCounter> {
public HoldCounter initialValue() {
return new HoldCounter();
}
}
写锁WriteLock的获取与释放
写锁是独占锁，可重入锁
- void lock()
public void lock() {
sync.acquire(1);
}
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
protected final boolean tryAcquire(int acquires) {
Thread current = Thread.currentThread();
int c = getState();
int w = exclusiveCount(c);
// 说明读锁或写锁已经被某线程获取
if (c != 0) {
// w=0：已经有线程获取了读锁；w!=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;
}
对于writerShouldBlock方法，非公平锁的实现为：
final boolean writerShouldBlock() {
return false;
}
公平锁的实现为：
final boolean writerShouldBlock() {
return hasQueuedPredecessors();
}
- void lockInterruptibly()：类似lock()，会对线程中断做出响应
- boolean tryLock()：尝试获取锁，1）若读写锁都没有被其他线程持有，获取成功；2）读写锁其中之一被其他线程持有，返回false，但不会被阻塞；3）当前线程已经持有则增加AQS状态值
public boolean tryLock( ) {
return sync.tryWriteLock();
}
final boolean tryWriteLock() {
Thread current = Thread.currentThread();
int c = getState();
if (c != 0) {
int w = exclusiveCount(c);
if (w == 0 || current != getExclusiveOwnerThread())
return false;
if (w == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
}
if (!compareAndSetState(c, c + 1))
return false;
setExclusiveOwnerThread(current);
return true;
}
- boolean tryLock(long timeout,TimeUnit unit)：多了超时时间。若尝试获取写锁失败则会挂起指定时间，超时时间过后线程激活，若还是获取失败则返回false。且该方法会对线程中断做出响应
- void unlock()：
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
protected final boolean tryRelease(int releases) {
// 判断当前线程是否为持有者
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
int nextc = getState() - releases;
boolean free = exclusiveCount(nextc) == 0;
if (free)
setExclusiveOwnerThread(null);
setState(nextc);
return free;
}
读锁ReadLock的获取与释放
- void lock()：
public void lock() {
sync.acquireShared(1);
}
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
protected final int tryAcquireShared(int unused) {
Thread current = Thread.currentThread();
// 当前状态值
int c = getState();
// 判断是否写锁被占用
if (exclusiveCount(c) != 0 &&
getExclusiveOwnerThread() != current)
return -1;
// 获取读锁计数
int r = sharedCount(c);
// 尝试获取锁，多个读线程只有一个会成功，不成功的进入fullTryAcquireShared进行重试
if (!readerShouldBlock() &&
r < MAX_COUNT &&
compareAndSetState(c, c + SHARED_UNIT)) {
// 第一个线程获取读锁
if (r == 0) {
firstReader = current;
firstReaderHoldCount = 1;
// 如果当前线程是第一个获取读锁的线程
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
// 记录最后一个获取读锁的线程或记录其他线程读锁的可重入数
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
cachedHoldCounter = rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
}
return 1;
}
// 类似tryAcquireShared，但为自旋获取
return fullTryAcquireShared(current);
}
其中非公平锁的readerShouldBlock()实现如下：
final boolean readerShouldBlock() {
return apparentlyFirstQueuedIsExclusive();
}
final boolean apparentlyFirstQueuedIsExclusive() {
Node h, s;
return (h = head) != null &&
(s = h.next) != null &&
!s.isShared() &&
s.thread != null;
}
fullTryAcquireShared()与tryAcquireShared()类似，不同之处在于前者采用循环自旋获取
final int fullTryAcquireShared(Thread current) {
HoldCounter rh = null;
for (;;) {
int c = getState();
if (exclusiveCount(c) != 0) {
if (getExclusiveOwnerThread() != current)
return -1;
// else we hold the exclusive lock; blocking here
// would cause deadlock.
} else if (readerShouldBlock()) {
// Make sure we're not acquiring read lock reentrantly
if (firstReader == current) {
// assert firstReaderHoldCount > 0;
} else {
if (rh == null) {
rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current)) {
rh = readHolds.get();
if (rh.count == 0)
readHolds.remove();
}
}
if (rh.count == 0)
return -1;
}
}
if (sharedCount(c) == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
if (compareAndSetState(c, c + SHARED_UNIT)) {
if (sharedCount(c) == 0) {
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
if (rh == null)
rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
cachedHoldCounter = rh; // cache for release
}
return 1;
}
}
}
- void lockInterruptibly()：会对线程中断做出响应
- boolean tryLock()：尝试获取锁，若没有其他线程持有写锁则获取成功，返回true；否则失败（不阻塞），返回false；若已持有读锁，则在增加state高16位
- boolean tryLock(long timeout,TimeUnit unit)：尝试获取锁，失败则挂起指定时间，超时后唤醒继续获取，失败则返回false；会对线程中断做出响应
- boid unlock()：
public void unlock() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
protected final boolean tryReleaseShared(int unused) {
Thread current = Thread.currentThread();
......
// 循环直到自己的读计数-1，CAS更新成功
for (;;) {
int c = getState();
int nextc = c - SHARED_UNIT;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
JDK 8中新增的StampedLock锁探究
StampedLock是并发包里面JDK 8版本新增的一个锁，该锁提供了三种模式的读写控制，当调用获取锁的系列函数时，会返回一个long型变量，我们称之为戳记（stamp），这个戳记代表了锁的状态。其中try系列获取锁的函数，当获取锁失败后会返回为0的stamp值。当调用释放锁和转换锁的方法时需要传入获取锁时返回的stamp值。
StampedLock提供的三种读写模式的锁分别如下：
- 写锁writeLock： 排他锁（独占锁），不可重入锁，提供了非阻塞的tryWriteLock()。获取锁成功后会返回一个stamp变量用来标示该锁的版本，释放锁需调用unlockWrite方法并传入该参数。
- 悲观锁readLock： 共享锁，不可重入锁，提供非阻塞的tryReadLock()。若其他线程持有写锁，则获取锁的线程会被阻塞。stamp值的使用同writeLock
- 乐观读锁tryOptimisticRead： 操作数据前没有通过CAS设置锁的状态，仅通过位运算测试。若当前没有线程获取写锁，则简单地返回非0stamp版本信息。在具体操作数据前还得调用validate验证该stamp是否已经不可用（即期间是否有其他线程获取写锁）。由于tryOptimisticRead并没有使用CAS设置锁状态，所以不需要显式地释放该锁。适用于读多写少的场景，因为获取读锁知识使用位操作进行检验，不涉及CAS操作，所以效率会高很多，但是同时由于没有使用真正的锁，在保证数据一致性上需要复制一份要操作的变量到方法栈，保证了读写的弱一致性。
StampLock还支持这三种锁在一定条件下进行互相转换。例如long tryConverToWriteLock(long stamp)期望把stamp标示的锁升级为写锁，该函数会在下面几种情况下返回一个有效的stamp（也就是晋升写锁成功）：
- 当前锁已经是写锁模式了
- 当前锁处于读锁模式，并且没有其他线程是读锁模式
- 当前处于乐观读模式，并且当前写锁可用
1）StampedLock的读写锁都是不可重入的；
2）多个线程获取锁的规则也是随机的；
3）该锁不是直接实现Lock或ReadWriteLock接口，而是在内部自己维护了一个双向阻塞队列
案例介绍
下面通过JDK 8里面提供的一个管理二维点的例子来理解以上介绍的概念。
import java.util.concurrent.locks.StampedLock;
public class Point {
private double x, y;
private final StampedLock sl = new StampedLock();
// 排他锁——写锁
void move(double deltaX, double deltaY) {
long stamp = sl.writeLock();
try {
x += deltaX;
y += deltaY;
} finally {
sl.unlock(stamp);
}
}
// 乐观读锁
double distanceFromOrigin() {
// 尝试获取乐观读锁
long stamp = sl.tryOptimisticRead();
// 将全部变量复制到方法体栈内
double currentX = x, currentY = y;
// 检查获取戳记后，锁有没被其他线程排他性抢占
if (!sl.validate(stamp)) {
// 如果被排他性抢占则获取一个共享读锁（悲观获取）
stamp = sl.readLock();
try {
currentX = x;
currentY = y;
} finally {
sl.unlock(stamp);
}
}
return Math.sqrt(currentX * currentX + currentY * currentY);
}
// 使用悲观锁获取读锁，并尝试转换为写锁
void moveIdAtOrigin(double newX, double newY) {
// 这里可以使用乐观读锁替换
long stamp = sl.readLock();
try {
while (x == 0.0 && y == 0.0) {
// 尝试将获取的读锁升级为写锁
long ws = sl.tryConvertToWriteLock(stamp);
// 升级成功后，则更新戳记，并设置坐标值，然后退出循环
if (ws != 0L) {
stamp = ws;
x = newX;
y = newY;
break;
} else {
// 读锁升级写锁失败则释放读锁，显式获取独占写锁，然后退出循环重试
sl.unlock(stamp);
stamp = sl.writeLock();
}
}
} finally {
sl.unlock(stamp);
}
}
}
StampLock提供的读写锁与ReentrantReadWriteLock类似，只是前者提供的是不可重入锁。但是前者通过提供乐观锁在多线程读的情况下提供了更好的性能，这是因为获取乐观读锁时不需要进行CAS操作这是锁的状态，而只是简单地测试状态。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
