AbstractQueuedSynchronizer 原理分析

简介

• 首先各种blocking lock 和 synchronizers (semaphores, events, etc)都是依赖于FIFO队列的。而AbstractQueuedSynchronizer 通过一个整型(int)的数值表示当前队列的状态，子类中可以通过getState/setStatye/compareAndSetState方法来改变队列状态。
• 两种模式：
  
  • 共享模式 shared mode 线程共享
  • 排他模式 exclusive mode 线程独占

数据结构

Queue中的节点 - Node

Node{
    int waitState;
    Node prev;
    Node next;
    Thread thread;//该节点加入队列时的线程
    Node nextWaiter;//等待Condition的节点
}

Node 中定义了Queue的运行模式shared/exclusive(default)

static final Node SHARED = new Node();
static final Node EXCLUSIVE = null;

waitStatus（节点状态）:

• CANCELLED 1 由于超时、被打断导致cancel。该线程不会再被阻塞。
• SIGNAL -1 这个记号表示当前node之后的节点已经或即将被阻塞，需要再release或者cancel后唤醒一个或若干个后续节点，在该节点被release/cancel的时候，需要唤醒后面的节点。
• CONDITION -2表示该节点处于CONDITION队列中。
• PROPAGATE -3 当前场景下后续的acquireShared能够得以执行。
• 0 表示当前节点在队列中，等待获取锁。

AbstractQueuedSynchronizer 持有Queue

{
    Node head;
    Node tail;
    int state;
}

AbstractQueuedSynchronizer 操作Queue

    getState();
    setState();
    Node enq(final Node node)//insert node;
    Node addWaiter(Node mode)// add waiter - shared/exclusive node
    //唤醒后面节点
    private void unparkSuccessor(Node node) {
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);//更新为0,表示等待锁
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            //从tail开始查找non-canceled node,然后唤醒他。
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

同步器实现

• 获取

public final void acquire(int arg) {
        if (!tryAcquire(arg) && //tryAcquire（）获取arg状态,依赖子类具体实现
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))//获取失败，将该节点插入tail,再次尝试获取。
            selfInterrupt();
    }

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)) {//前驱是头结点，获取状态成功。头结点代表正在占有锁。
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //获取失败-当前节点没有获取状态，继续回到队列中继续等待。
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

从上面的代码中可以看出，acquire会忽略Interruption，为此代码提供者还实现了可终止的方法来获取状态-抛异常。

public final void acquireInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (!tryAcquire(arg))
            doAcquireInterruptibly(arg);
    }
    //doAcquireInterruptibly 处理方式同上面的处理方式是相似的，只不过在获取失败的时候，会抛异常 throw new InterruptedException();

• 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;
    }
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);//唤醒节点
    }

ReentrantLock#FairSync 中的实现

• lock

final void lock() {
  acquire(1);
}
//AbstractQueuedSynchronizer#acquire()
public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
 // ReentrantLock#FairSync#tryAcquire
 protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();//获取当前队列的状态
            if (c == 0) {//state == 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;
        }

• release

protected final boolean tryRelease(int releases) {
            int c = getState() - releases;//正常情况下，getState() 和releases是相等的。
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);//
            }
            setState(c);
            return free;
        }

疑问点：

1. unparkSuccessor 中 查找non-canceled node 为什么需要从tail开始查找？