AbstractQueuedSynchronizer 源码分析

//返回当前值
    protected final int getState() {
        return state;
    }

	//设置同步值
    protected final void setState(int newState) {
        state = newState;
    }

	//原子操作 CAS
    protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

// ReentrantLock 构造方法
// 默认非公平锁
public ReentrantLock() {
    sync = new NonfairSync();
}

// 传入true，创建公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

public class ReentrantLockTest {

    public static void main(String[] args) {
        // 创建公平锁
        ReentrantLock lock = new ReentrantLock();
        // 加锁
        lock.lock();
        hello();
        // 解锁
        lock.unlock();
    }

    public static void hello() {
        System.out.println("Say Hello World!");
    }
}

public void lock() {
    sync.lock();
}

abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = -5179523762034025860L;

    // 抽象方法，由公平锁和非公平锁具体实现
    abstract void lock();

    // ..... 代码省略

}

/**
 * Performs lock.  Try immediate barge, backing up to normal
 * acquire on failure.
 */
final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

public final void acquire(int arg) {
    // 第一个调用了tryAcquire方法，这方法判断能不能拿到锁
    // 强调，这里的tryAcquire的结果，最后是取反，最前面加了 ！运算
    if (!tryAcquire(arg) &&
        // 这里有两个方法  addWaiter 和 acquireQueued
        // addWaiter 是入队
        // acquireQueued 是获取锁和进入等待
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
    selfInterrupt();
}

protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}

/**
 * Sync object for non-fair locks
 */
static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**
     * Performs lock.  Try immediate barge, backing up to normal
     * acquire on failure.
     */
    final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

    // 尝试获取锁 拿到锁了返回：true，没拿到锁返回：false
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

/**
 * Base of synchronization control for this lock. Subclassed
 * into fair and nonfair versions below. Uses AQS state to
 * represent the number of holds on the lock.
 */
abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = -5179523762034025860L;

    /**
     * Performs {@link Lock#lock}. The main reason for subclassing
     * is to allow fast path for nonfair version.
     */
    abstract void lock();

    /**
     * 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();
        if (c == 0) {
            //case 修改为 1 
            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;
    }

    protected final boolean tryRelease(int releases) {
        int c = getState() - releases;
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        setState(c);
        return free;
    }
    // ....	
}

public final void acquire(int arg) {
    // tryAcquire执行完，回到这里
    if (!tryAcquire(arg) &&
        // Node.EXCLUSIVE 这里传进去的参数是为null，在Node类里面
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
    selfInterrupt();
}

private Node addWaiter(Node mode) {
    // 因为在AQS队列里面，节点元素是Node，所以需要把当前类包装成一个node节点
    Node node = new Node(Thread.currentThread(), mode);
    // 把尾节点，赋值给pred，这里一共分两种两种情况
    Node pred = tail;
    // 判断尾部节点等不等于null，如果队列没有被初始化，tail肯定是个空
    // 反而言之，如果队列被初始化了，head和tail都不会为空
    if (pred != null) {
        // 整个就是维护链表关系
        // 把当前需要加入队列元素的上一个节点，指向队列尾部
        node.prev = pred;
        // CAS操作，如果队列的尾部节点是等于pred的话，就把tail 设置成 node，这个时候node就是最后一个节点了
        if (compareAndSetTail(pred, node)) {
            // 把之前尾部节点的next指向最后的的node节点
            pred.next = node;
            return node;
        }
    }
    // 初始化队列
    enq(node);
    return node;
}

// 整个方法就是初始化队列，并且把node节点追加到队列尾部
private Node enq(final Node node) {
    // 进来就是个死循环，这里看代码得知，一共循环两次
    for (;;) {
        Node t = tail;
        // 第一次进来tail等于null
        // 第二次进来由于下面代码已经把tail赋值成一个为空的node节点，所以t现在不等于null了
        if (t == null) {
            // CAS把head设置成一个空的Node节点
            if (compareAndSetHead(new Node()))
                // 把空的头节点赋值给tail节点
                tail = head;
        } else {
            // 第二次循环就走到这里，先把需要加入队列的上一个节点指向队列尾部
            node.prev = t;
            // CAS操作判断尾部是不是t如果是，则把node设置成队列尾部
            if (compareAndSetTail(t, node))  {
                // 再把之前链表尾部的next属性，连接刚刚更换的node尾部节点
                t.next = node;
                return t;
            }
        }
    }
}

if (compareAndSetHead(new Node()))
    // 把空的头节点赋值给tail节点
    tail = head;

// 第二次循环就走到这里，先把需要加入队列的上一个节点指向队列尾部
node.prev = t;
// CAS操作判断尾部是不是t如果是，则把node设置成队列尾部
if (compareAndSetTail(t, node))  {
    // 再把之前链表尾部的next属性，连接刚刚更换的node尾部节点
    t.next = node;
    return t;
}

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        // addWaiter返回Node，紧接着调用acquireQueued 方法
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
    selfInterrupt();
}

// node == 需要进队列的节点、arg = 1
final boolean acquireQueued(final Node node, int arg) {
    // 一个标记
    boolean failed = true;
    try {
        // 一个标记
        boolean interrupted = false;
        // 又来一个死循环
        for (;;) {
            // 获取当前节点的上一个元素，要么就是为头部节点，要么就是其他排队等待的节点
            final Node p = node.predecessor();
            // 判断是不是头部节点，如果是头部节点则代表当前节点是排队在第一个，有资格去获取锁，也就是自旋获取锁
            // 如果不是排队在第一个，前面的人还在排队后面的就更别说了去获取锁了
            // 就比如食堂打饭，有人正在打饭，而排队在第一个人的可以人，可以去看看前面那个人打完了没
            // 因为他前面没有没人排队，而后面的人就不同，前面的人还在排队，那么自己就只能老老实实排队了
            if (p == head && tryAcquire(arg)) {
                // 如果能进入到这里，则代表前面那个打饭的人已经搞完了，可以轮第一个排队的人打饭了
                // 既然前面那个人打完饭了，就可以出队列了，会把thread、prev、next置空，等待GC回收
                setHead(node);
                p.next = null; // help GC
                failed = false;
                // 返回false，整个acquire方法返回false，就出去了
                return interrupted;
            }
            // 如果不是头部节点，就要过来等待排队了
            // shouldParkAfterFailedAcquire 这方法会使当前循环再循环一次，相当于自旋一次获取锁
            if (shouldParkAfterFailedAcquire(p, node) &&
                // 队列阻塞，整个线程就等待被唤醒了 
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

// 调用方法，代码在下面
setHead(node);
p.next = null; // help GC

private void setHead(Node node) {
    head = node;
    node.thread = null;
    node.prev = null;
}

// 如果不是头部节点，就要过来等待排队了
// shouldParkAfterFailedAcquire 这方法会使当前循环再循环一次，相当于自旋一次获取锁
if (shouldParkAfterFailedAcquire(p, node) &&
    // 队列阻塞，整个线程就等待被唤醒了 
    parkAndCheckInterrupt())
    interrupted = true;

private final boolean parkAndCheckInterrupt() {
    // 在这里被park，等待unpark，如果该线程被unpark，则继续从这里执行
    LockSupport.park(this);
    // 这个是获取该线程是否被中断过，这句代码需要结合lockInterruptibly方法来讲，小编就不详细说了，不然一篇文章讲太多了～～～～
    return Thread.interrupted();
}

//pred 当前上一个节点，node 当前节点
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 第一次循环进来：获取上一个节点的线程状态，默认为0
    // 第二次循环进来，这个状态就变成-1了，
    int ws = pred.waitStatus;
    // 判断是否等于-1，第一进来是0，并且会吧waitStatus状态改成-1，代码在else
    // 第二次进来就是-1了，直接返回true，是当前线程进行阻塞
    if (ws == Node.SIGNAL)
        /*
        * This node has already set status asking a release
        * to signal it, so it can safely park.
        */
        return true;
    // 判断是否大于0，waitStatus分几种状态，这里其他几种状态的源码就不一一讲了。
    // = 1：由于在同步队列中等待的线程，等待超时或者被中断，需要从同步队列中取消等待，该节点进入该状态不会再变化
    // = -1：后续节点的线程处于等待状态，而当前节点的线程如果释放了同步状态或者被取消，将会通知后续节点，使后续节点继续运行
    // = -2：节点在等待队列中，节点线程在Condition上，当其他线程对Condition调用了signal()方法后，该节点将会从等待队列中转移到同步队列中，加入到同步状态中获取
    // = -3：表示下一次共享式同步状态获取将会无条件地被传播下去
    // = 0 ：初始状态
    if (ws > 0) {
        /*
        * Predecessor was cancelled. Skip over predecessors and
        * indicate retry.
        */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
        // 因为默认0，所以第一次会走到else方法里面    
    } else {
        // CAS吧waitStatus修改成-1
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    // 返回false，外层方法接着循环操作
    return false;
}

public class ReentrantLockTest {

    public static void main(String[] args) {
        // 创建公平锁
        ReentrantLock lock = new ReentrantLock(true);
        // 加锁
        lock.lock();
        hello();
        // 解锁
        lock.unlock();
    }

    public static void hello() {
        System.out.println("Say Hello");
    }
}

public void unlock() {
    sync.release(1);
}

public final boolean release(int arg) {
    // tryRelease 释放锁，如果真正释放会把当前持有锁的线程赋值为空，否则只是计数器-1
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

protected final boolean tryRelease(int releases) {
    // 获取锁计数器 - 1
    int c = getState() - releases;
    // 判断当前线程 是否等于 持有锁的线程，如果不是则抛出异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 返回标志
    boolean free = false;
    // 如果计算器等于0，则代表需要真正释放锁，否则是代表重入次数-1
    if (c == 0) {
        free = true;
        // 将持有锁的线程赋值空
        setExclusiveOwnerThread(null);
    }
    // 重新设置state状态
    setState(c);
    return free;
}

public final boolean release(int arg) {
    // tryRelease方法返回true，则表示真的需要释放锁
    if (tryRelease(arg)) {
        // 如果是需要真正释放锁，先获取head节点
        Node h = head;
        // 第一种情况，假设队列没有被初始化，这个时候head是为空的，则不需要进行锁唤醒
        // 第二种情况，队列被初始化了head不为空，并且只要有线程在队列中排队，waitStatus在被加入队列之前，会把当前节点的上一个节点的waitStatus改为-1
        // 所以只有满足h != null && h.waitStatus != 0 这个条件表达式，才能真正代表有线程正在排队
        if (h != null && h.waitStatus != 0)
            // 解锁操作，传入头节点信息
            unparkSuccessor(h);
        return true;
    }
    return false;
}

private void unparkSuccessor(Node node) {
    // 先获取head节点的状态，应该是等于-1，原因在shouldParkAfterFailedAcquire方法中有体现
    int ws = node.waitStatus;
    // 由于-1会小于0，所以重新改为0
    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);
    }
}

private final boolean parkAndCheckInterrupt() {
    // 在这里被park，等待unpark，如果该线程被unpark，则继续从这里执行
    LockSupport.park(this);
    // 这个是获取该线程是否被中断过，这句代码需要结合lockInterruptibly
    return Thread.interrupted();
}

// 不要小看以下几行代码，涉及的场景比较复杂
public final boolean hasQueuedPredecessors() {
    // 分别把尾节点、头节点赋值给 t、h
    Node t = tail;
    Node h = head;
    Node s;
    // AQS队列如果没有发生竞争，刚开始都是未初始化的，所以一开始tail、head都是为null
    // 第一种情况：AQS队列没有初始化的情况
    // 假设线程一,第一个进来，这个时候t、h都是为null,所以在h != t,这个判断返回false，由于用的是&&所以整个判断返回fase
    // 返回flase表示不需要排队。
    // 但是也不排除可能会有两个线程同时进来判断的情况，假设两个线程发现自己都不需要排队，就跑去CAS进行修改计数器，这个时候肯定会有一个失败的
    // CAS 是可以保证原子性操作的，假设线程一它CAS成功了，那么线程二就会去初始化队列，老老实实排队去了

    // 第二种情况：AQS队列被初始化了
    // 场景一：队列元素大于1个点情况，假设有一个线程在排队，在队列中应该有而个元素，一个是头节点、线程2
    // 现在线程2之前的线程已经执行完，并且释放锁唤醒线程2.线程2又会继续醒来循环。并且线程二是第一个排队的，所以有资格获取锁
    // 只要是获取锁就会来排队需不需要排队，代码又回到这里
    // 现在 h = 等于头节点，而 tail = 线程2的node节点，所以 h != t 结果为true
    // h表示头节点，并且h.next是线程2的节点，所以 (s = h.next) == null 返回 flase
    // s 等于 h.next，也就是线程2的节点信息，并且当前执行的线程也是线程2，所以 s.thread != Thread.currentThread()，返回false
    // 最后return的结果是 true && false，结果为false，代表不需要排队

    // 场景二：队列元素等于1个，什么情况下队列被初始化了并且只有一个元素呢？
    // 当有线程竞争初始化队列，之后队列又全部都被消费完了。最后剩下一个为空的node，并且head和tail都指向它
    // 这个时候有新的线程进来，其实h != t,直接返回false，因为head 和tail都指向最后一个节点了

    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}