JUC-Lock
- Lock接口:
- Lock接口定义了比同步原语更灵活、更轻巧锁机制;同时,支持多种条件关联锁
- JUC的Lock接口的基本实现为ReentrantLock
- ReentrantLock支持公平、非公平、可重入的互斥同步锁
ReentrantLock
1.ReentrantLock分为两种实现,非公平以及公平模式;
2.公平模式基于CAS+队列实现,而非公平模式则是仅基于CAS实现
3.ReentrantLock中的队列,本质上是基于AQS实现的;而AQS本质上只是一个维持了内存可见的state的双向队列
- ReentrantLock中Node的状态字
//代表当前线程取消竞争锁
static final int CANCELLED = 1;
//代表当前节点正常
static final int SIGNAL = -1;
//代表当前线程在等待条件
static final int CONDITION = -2;
//无法理解.......
static final int PROPAGATE = -3;
//表示状态字;只能用于以上四个状态字以及0
volatile int waitStatus;
- ReentrantLock构造方法
//默认为非公平实现
public ReentrantLock() {
sync = new NonfairSync();
}
//通过传入fair变量控制;
//fair=true,公平锁实现;否则非公平实现
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
- sync是什么?
- Sync是基于AQS实现的ReentrantLock锁同步控制基础
- 如下:
- ReentrantLock#lock()方法
final void lock() {
acquire(1);
}
- ReentrantLock中acquire方法基于AQS
public final void acquire(int arg) {
//至少尝试获取一次锁;
//如果锁没有获取成功,则将当前线程加入等待队列;
//并且中断当前线程
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
- ReentrantLock#tryAcquire(int args)
- 尝试获取锁的公平版本
- 非公平版本其实就是略去了公平版本的队列判断:hasQueuedPredecessors()
protected final boolean tryAcquire(int acquires) {
//当前线程ID
final Thread current = Thread.currentThread();
//当前锁状态
int c = getState();
//如果当前锁无人占有
if (c == 0) {
//公平锁讲究先来后到
//如果当前等待队列没有等待线程,
//且通过CAS成功改变锁的状态
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
//设置当前锁持有的线程
setExclusiveOwnerThread(current);
return true;
}
}
//如当前事务请求线程与当前事务执行线程是一样的;可重入锁特性
//这里就是可重入锁特性:同一线程可以重复获取同一把锁
else if (current == getExclusiveOwnerThread()) {
//那么将当前锁持有状态+1
//通过设置acquires=1来完成可重入锁特性
int nextc = c + acquires;
//这里对可重入锁的限制,当同一线程持有锁达到int的上限时;
//会抛出异常
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
//并且重新改变state
setState(nextc);
return true;
}
return false;
}
- ReentrantLock#addWaiter()
- 将当前等待线程以排它模式入队
private Node addWaiter(Node mode) {
//以当前线程建立Node,并且设置Node的模式为排它
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
if (pred != null) {
node.prev = pred;
//通过CAS修改队尾指针,新增等待线程
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
//通过自旋追加节点
enq(node);
return node;
}
- ReentrantLock#acquireQueued()
- 通过自旋不停的获取锁
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
//获取p的前置节点
final Node p = node.predecessor();
//如果p的前置节点为head哑节点
//则说明p节点为阻塞队列的对头元素
//在AQS的CLH队列中,只有队头元素才能抢占锁
//且尝试获取锁成功,则返回false
//当返回false时,则说明当前线程不需要挂起
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
//如果事情发展到这一步;
//则说明前一步骤中,当前线程不在队列的头部
//或者没有抢占锁成功,则需要将当前线程挂起
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
//当自身获取锁出现异常时
if (failed)
cancelAcquire(node);
}
}
- ReentrantLock#shouldParkAfterFailedAcquire()
- 检验当前线程是否需要挂起
- 每个线程第一次进入该方法时,都为false;当第二次进入时才为true
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//前驱节点状态字
int ws = pred.waitStatus;
//前驱节点正常;我需要挂起
if (ws == Node.SIGNAL)//-1
return true;
//当状态字大于0,说明前驱节点取消竞争锁;
//此时不停的寻找状态字小于0的节点;
//因为前驱节点的状态字影响了自身的行为;
//自身线程的行为依赖于前驱节点的状态字
if (ws > 0) {//1
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
//当一个新的节点进入队列时,默认status为0;
//因此需要将前驱节点的status设置为-1;
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
- ReentrantLock#parkAndCheckInterrupt()
- 挂起当前线程
private final boolean parkAndCheckInterrupt() {
//挂起当前线程
LockSupport.park(this);
return Thread.interrupted();
}
- ReentrantLock#release()
- 释放当前线程,唤醒等待线程
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
//唤醒后继节点线程
unparkSuccessor(h);
return true;
}
return false;
}
- ReentrantLock#tryRelease()
- 尝试释放当前线程
protected final boolean tryRelease(int releases) {
//state表示锁状态;亦是当前线程持有锁的数目
//可重入锁的释放
int c = getState() - releases;
//如果当前线程不是锁的持有者
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
//如果说c==0;则说明当前线程持有的锁已经完全释放
//可重入锁,一个线程可以多次请求同一把锁
if (c == 0) {
free = true;
//设置当前锁的持有线程为null
setExclusiveOwnerThread(null);
}
//修改状态位
setState(c);
return free;
}
- ReentrantLock#unparkSuccessor()
- 唤醒后继线程
private void unparkSuccessor(Node node) {
//head节点的状态
int ws = node.waitStatus;
if (ws < 0)
//修改head节点的状态,以影响后继节点
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
//从后面往前面找,找最接近头节点的小于0的线程
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
//如果存在状态位小于0的线程
if (s != null)
//唤醒线程
LockSupport.unpark(s.thread);
}
