实际上Lock实现类继承了内部类的sync实例,而这个sync就是abstractQueuedSynchroizer(AQS)
FairSync 与 NonfairSync 的区别在于,是不是保证获取锁的公平性,因为默认是 NonfairSync(非公平性)
lock有公平锁和非公平锁,而synchroized只有非公平锁
是jdk提供的一个同步框架,内部维护这FIFO的双向队列,即CLH同步队列
AQS依赖它来完成同步状态的管理(voliate修饰的state,用于标志是否持有锁)。如果获取同步状态的state失败时,会将当前线程及等待信息等构建一个Node,将Node放在FIFO队列中,同时阻塞当前线程,当线程将同步状态state释放时,会把FIFO队列中的首节的唤醒,使其获取同步状态state。
AQS的功能在使用中可以分为两种:独占锁 和 共享锁
独占锁:每次只能有一个线程持有锁。eg:ReentrantLock就是独占锁
共享锁:允许多个线程同时获得锁,并发访问共享资源。eg:ReentrantReadWriteLock中的读锁、CountDownLatch
实际上是依靠node这个静态内部类来实现的
此处,node相当于一个包装类,一个双向链表的结构。
node的实际用处:如果当前线程执行时发现,已经有其他线程获取到了锁,AQS就会将当前线程包装成一个node节点,添加到同步队列中,同时使队列阻塞。
- SIGNAL:值为-1,后继节点的线程处于等待状态,如果当前节点的线程释放了同步状态或者被取消时,将会通知后继节点,使后继节点得以运行。
- CANCELLED:值为1,由于在同步队列中等待的线程等待超时、被中断时,需要从同步队列中取消等待,节点进入该状态将不会变化。
- CONDITION:值为-2,节点在等待队列中,节点线程等待在 Condition 上,当其他线程对 Condition 调用了 signal()方法后,该节点将会从等待队列中转移至同步队列中,加入到对同步状态的获取中来。
- PROPAGATE:值为-3,表示下一次共享式同步状态获取将会无条件的被传播下去。
- INITIAL:值为0,初始状态。
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
获取锁
tryAcquire
尝试去获取锁,获取成功返回true,否则返回false。该方法由AQS的子类自己实现。采用了模板方法和设计模式。
addWriterprivate Node addWaiter(Node mode) {
//新建节点,加入到队列的尾部
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;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);//一直for循环
return node;
}
enq , 一直for循环,知道添加成功为止
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
acquireQueued 不断的去获取同步锁的过程
final boolean acquireQueued(final Node node, long arg) {
//操作是否成功的标记
boolean failed = true;
try {
// 线程中断标记
boolean interrupted = false;
// 不断的自旋
for (;;) {
// 获取当前节点的prev节点
final Node p = node.predecessor();
//如果当前节点为头节点,且 是否获取到同步状态
if (p == head && tryAcquire(arg)) {
// 就设置该节点为头节点
setHead(node);
// 将prev 移除队列中
p.next = null; // help GC
failed = false;
return interrupted;
}
//自旋的过程中,需要判断当前的线程是否需要阻塞 && 阻塞当前线程并且检验线程中
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
shouldParkAfterFailedAcquire
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//拿到prev节点的等待状态
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
return true;
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
parkAndCheckInterrupt
private final boolean parkAndCheckInterrupt() {
//阻塞当前线程
LockSupport.park(this);
//返回当前线程的中断状态
return Thread.interrupted();
}
selfInterrupt
static void selfInterrupt() {
// 未获取到同步状态 && 线程中断状态为true,中断当前线程
Thread.currentThread().interrupt();
}
释放锁
release
public final boolean release(long arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
tryRelease
尝试去释放同步状态,释放成功后返回true,否则返回false。该方法由继承AQS的子类自己去实现。采用了模板方法设计模式
protected boolean tryRelease(long arg) {
throw new UnsupportedOperationException();
}
unparkSuccessor
private void unparkSuccessor(Node node) {
//获取当前节点的等待状态
int ws = node.waitStatus;
// 如果当前节点的状态 < 0 , 那么将CAS设置成0
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
//获取后继节点
Node s = node.next;
// 如果后继节点为空 || 伙计节点的状态 > 0 (为取消状态)
if (s == null || s.waitStatus > 0) {
s = null;
//从尾节点查找状态不为取消的可用节点
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
// 唤醒后继节点
LockSupport.unpark(s.thread);
}
共享模式下的同步状态
acquireShared
public final void acquireShared(long arg) {
if (tryAcquireShared(arg) < 0)
//如果获取失败后,自旋获取同步状态
doAcquireShared(arg);
}
tryAcquireShared
protected long tryAcquireShared(long arg) {
throw new UnsupportedOperationException();
}
doAcquireShared
private void doAcquireShared(long arg) {
//添加共享模式节点到队列中
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
boolean interrupted = false;
//自旋获取其同步状态
for (;;) {
//获取其前驱节点
final Node p = node.predecessor();
if (p == head) {
//尝试去获取共享同步状态
long r = tryAcquireShared(arg);
if (r >= 0) {
// 将当前节点设置为头节点,并且释放也是共享模式的后继节点
setHeadAndPropagate(node, r);
p.next = null; // help GC
if (interrupted)
selfInterrupt();
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
setHeadAndPropagate
private void setHeadAndPropagate(Node node, long propagate) {
Node h = head; // Record old head for check below
setHead(node);
//
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;
if (s == null || s.isShared())
//真正的释放共享同步状态,并唤醒下一个节点
doReleaseShared();
}
}
doReleaseShared
private void doReleaseShared() {
//自旋释放共享同步状态
for (;;) {
Node h = head;
// 如果头节点不为空 && 头节点不等于尾节点,说明存在有效的node节点
if (h != null && h != tail) {
int ws = h.waitStatus;
//如果头节点的状态为signal,说明存在需要唤醒的后继节点
if (ws == Node.SIGNAL) {
//将头节点状态更新为0(初始值状态),因为此时头节点已经没有用了,
//continue是为了保证替换成功。
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
//唤醒后继节点
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}
unparkSuccessor
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);
}



