AQS原理
以非公平锁为例子：
package com.jmdf.redis.project.aqs;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TestAQS {
private static Lock lock = new ReentrantLock();
public static void main(String[] args) {
Thread[] threads = new Thread[3];
for (int i = 0;i<threads.length;i++) {
threads[i] = new Thread(()->{
lock.lock(); //①→加锁
try { Thread.sleep(Integer.MAX_VALUE); }catch(Exception e){ }
finally {
lock.unlock(); ②→//解锁
}
},"Thread"+i);
}
for (Thread thread :threads) thread.start();
for (Thread thread :threads) try { thread.join(); } catch (InterruptedException e) { e.printStackTrace(); }
}
}
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
if (compareAndSetState(0, 1)) //unsafe.compareAndSwapInt(this, stateOffset, expect, update);
setExclusiveOwnerThread(Thread.currentThread()); //当前锁的所有权线程
//if段操作后面还有，前面重复为了提高性能。
else
acquire(1); //获取锁失败→
}
/**
* Acquires in exclusive mode, ignoring interrupts. Implemented
* by invoking at least once {@link #tryAcquire},
* returning on success. Otherwise the thread is queued, possibly
* repeatedly blocking and unblocking, invoking {@link
* #tryAcquire} until success. This method can be used
* to implement method {@link Lock#lock}.
*
* @param arg the acquire argument. This value is conveyed to
* {@link #tryAcquire} but is otherwise uninterpreted and
* can represent anything you like.
*/
public final void acquire(int arg) {
if (!tryAcquire(arg) && //①→尝试获取锁
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))//addWaiter(Node.EXCLUSIVE)尝试获取锁失败，自旋CAS加入CHL队列,acquireQueued 方法 自旋尝试获取锁
selfInterrupt(); //中断
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
/**
* Performs non-fair tryLock. tryAcquire is implemented in
* subclasses, but both need nonfair try for trylock method.
* 非公平锁实现
*/
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread(); //当前线程，局部变量在虚拟机栈里
int c = getState(); //volatile修饰的int变量
if (c == 0) { //前面的线程获取锁，完成业务后，占用的锁释放了
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) { //state !=0,当前线程等于Lock实现类锁所有权线程，则为可重入锁，不需要获取锁，只需要state++;
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false; //当前线程尝试获取锁失败。
}
/**
* Fair version of tryAcquire. Don't grant access unless
* recursive call or no waiters or is first.
* 公平锁实现
*/
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;
}
/ * if there is a queued thread preceding the
* current thread, and {@code false} if the current thread
* is at the head of the queue or the queue is empty
* @since 1.7
* 公平锁判断队列为空才去尝试获取锁，高并发情况下并非绝对公平
*/
public final boolean hasQueuedPredecessors() {
// The correctness of this depends on head being initialized
// before tail and on head.next being accurate if the current
// thread is first in queue.
Node t = tail; // Read fields in reverse initialization order 尾节点
Node h = head; //头节点
Node s;
return h != t && //h!=t 为false==→空队列，后面判断是为了防止并发
((s = h.next) == null || s.thread != Thread.currentThread());
}
private 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);
return node;
}
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // Must initialize
if (compareAndSetHead(new Node())) //延迟初始化队列节点 在AQ类加载时声明了成员节点，static{}获取了head、tail、pre、next在jvm里的位置的偏移量，为以后cas做准备
tail = head; //头尾节点相等，队列初始化结束，队列为空
} else {
node.prev = t; // tail ←prev node
if (compareAndSetTail(t, node)) {//若队列不为空，尾节点指针指向当前节点的前置节点，cas 把当前node.next =null 尾节点cas成功！ node next→null
t.next = node; // tail next→node
return t;
}
}
}
}
/**
* Acquires in exclusive uninterruptible mode for thread already in
* queue. Used by condition wait methods as well as acquire.
*
* @param node the node
* @param arg the acquire argument
* @return {@code true} if interrupted while waiting
*/
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();//node 节点的前置节点
if (p == head && tryAcquire(arg)) { //如果前置节点为head ,则可以尝试获取锁
setHead(node); //把该节点设置为head节点
p.next = null; // help GC 释放 node节点的前置节点，从队列中清除
failed = false;
return interrupted; //false
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
private void setHead(Node node) {
head = node;
node.thread = null;
node.prev = null;
}