ReentrantLock和AbstractQueuedSynchronizer源码解读

ReentrantLock lock = new ReentrantLock();
lock.lock();
lock.unlock();

首先解释几个成员变量：

 

抽象类AbstractQueuedSynchronizer中：

内部类Node：获取锁失败的线程会封装成Node放入到队列

head：同步队列的头Node

tail：同步队列的尾Node

state：是一个int值，0代表无锁，1代表有锁，越大就代表重入次数

 

ReentrantLock中：

内部抽象类Sync：继承AQS

类NonfairSync：继承Sync

类FairSync:继承Sync

 

下面开始看源码：

 

ReentrantLock构造方法：

public ReentrantLock() {
    sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

可以看到默认是非公平锁。

我们先分析非公平锁，获取锁：

ReentrantLock#lock()入口进去:

private final Sync sync;

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

static final class NonfairSync extends Sync {
    
    final void lock() {
        if (compareAndSetState(0, 1))
            //这里体现了非公平锁的特性
            //先通过Cas操作，争抢锁，如果成功则state为1，并且记录获取锁的线程为当前线程
            setExclusiveOwnerThread(Thread.currentThread());
        else
            //争抢锁失败，则进入到同步队列
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

上面的cas操作在AQS类中，解读下

private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long stateOffset;
private static final long headOffset;
private static final long tailOffset;
private static final long waitStatusOffset;
private static final long nextOffset;
static {
    try {
        stateOffset = unsafe.objectFieldOffset
            (AbstractQueuedSynchronizer.class.getDeclaredField("state"));
        headOffset = unsafe.objectFieldOffset
            (AbstractQueuedSynchronizer.class.getDeclaredField("head"));
        tailOffset = unsafe.objectFieldOffset
            (AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
        waitStatusOffset = unsafe.objectFieldOffset
            (Node.class.getDeclaredField("waitStatus"));
        nextOffset = unsafe.objectFieldOffset
            (Node.class.getDeclaredField("next"));
    } catch (Exception ex) { throw new Error(ex); }
}
protected final boolean compareAndSetState(int expect, int update) {
    //如果当前内存中的state 的值和预期值 expect 相等，则替换为 update。更新成功返回 true，否则返回 false.
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

一个 Java 对象可以看成是一段内存，每个字段都得按照一定的顺序放在这段内存里，通过这个方法可以准确地告诉你某个字段相对于对象的起始内存地址的字节

偏移。用于在后面的 compareAndSwapInt 中，去根据偏移量找到对象在内存中的具体位置

所以 stateOffset 表示 state 这个字段在 AQS 类的内存中相对于该类首地址的偏移量。

接下来看争抢失败放入同步队列的逻辑：

AbstractQueuedSynchronizer#acquire(int arg)

public final void acquire(int arg) {
    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        //如果获取锁失败，则把线程封装成Node放入到同步队列队尾
        selfInterrupt();
}

AbstractQueuedSynchronizer#tryAcquire

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

这里是模板方法，由子类去实现。这里就是NonFairSync实现了tryAcquire方法。

protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        //表示当前无锁，cas操作修改state值，如果成功，则记录当前线程获取到了锁
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        //如果是有锁状态，并且锁占有者是当前线程，则重入，state值+参数
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

如果tryAcquire返回false，获取锁失败，则会调用acquireQueued(addWaiter(Node.EXCLUSIVE), arg))：

先看AbstractQueuedSynchronizer#addWaiter(Node.EXCLUSIVE), arg)方法：

private Node addWaiter(Node mode) {
    //将当前线程封装成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) {
        //尾节点不是null，则cas设置新的Node为尾节点，旧的尾节点的next指向新尾节点，同时新尾节点的pred指向旧的尾巴节点
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    //队列没有tail Node，则会初始化
    enq(node);
    return node;
}

/**
* Inserts node into queue, initializing if necessary. See picture above.
* @param node the node to insert
* @return node's predecessor
*/
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                //原先没有Node，则初始化，头尾互相指向
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

线程封装成Node，放入到AQS队列后，调用AbstractQueuedSynchronizer#acquireQueued(final Node node, int arg)方法，

通过自旋去获取锁：

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            //获取当前Node的前继Node
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                //如果前继节点是head，当前节点就有资格去争抢锁。如果获取锁成功，则设置当前节点为head节点，移除旧的hea节点
                setHead(node);
                p.next = null; // help GC 把原head节点从链表移除
                failed = false;
                return interrupted;
            }
            //返回 false 时，也就是不需要挂起，返回 true，则需要调用 parkAndCheckInterrpt挂起当前线程
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

AbstractQueuedSynchronizer#shouldParkAfterFailedAcquire(Node pred, Node node):

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        //pred 节点状态为 SIGNAL，那就表示可以放心挂起当前线程
        return true;
    if (ws > 0) {
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
        //通过循环扫描链表把 CANCELLED 状态的节点移除
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * waitStatus must be 0 or PROPAGATE.  Indicate that we
         * need a signal, but don't park yet.  Caller will need to
         * retry to make sure it cannot acquire before parking.
         */
        //修改 pred 节点的状态为 SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

Node 有 5 中状态，分别是：CANCELLED（1），SIGNAL（-1）、CONDITION（-2）、PROPAGATE(-3)、默认状态(0)

CANCELLED: 在同步队列中等待的线程等待超时或被中断，需要从同步队列中取消该 Node 的结点, 其结点的 waitStatus 为 CANCELLED，即结束状态，进入该状态后的结点将不会再变化

SIGNAL: 只要前置节点释放锁，就会通知标识为 SIGNAL 状态的后续节点的线程

CONDITION： 和 Condition 有关系

PROPAGATE：共享模式下，PROPAGATE 状态的线程处于可运行状态

0:初始状态

分析完获取锁，再分析释放锁：

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

AbstractQueuedSynchronizer#release(int arg)：

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            //唤醒后续线程
            unparkSuccessor(h);
        return true;
    }
    return false;
}

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

private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    //获得head节点的状态
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    /*
     * Thread to unpark is held in successor, which is normally
     * just the next node.  But if cancelled or apparently null,
     * traverse backwards from tail to find the actual
     * non-cancelled successor.
     */
    Node s = node.next;
    //如果下一个节点为 null 或者 status>0 表示 cancelled 状态.
    //通过从尾部节点开始扫描，找到距离 head 最近的一个waitStatus<=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);
}

ReentrantLock.Sync#tryRelease(int releases):

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        //state=0的时候代表完全释放掉锁，并清除当前线程表示
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

为什么在释放锁的时候是从 tail 进行扫描？

再把Node放入队列的方法中，比如enq(Node node)

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;//1
            if (compareAndSetTail(t, node)) {//2
                t.next = node;//3
                return t;
            }
        }
    }
}

在 cas 操作之后，t.next=node 操作之前。存在其他线程调用 unlock 方法从 head开始往后遍历，由于 t.next=node 还没执行意味着链表的关系还没有建立完整。

就会导致遍历到 t 节点的时候被中断。所以从后往前遍历，一定不会存在这个问题。

 

非公平锁和公平锁区别？

锁的公平性是相对于获取锁的顺序而言的，如果是一个公平锁，那么锁的获取顺序

就应该符合请求的绝对时间顺序，也就是 FIFO。非公平锁只要CAS 设置同步状态成功，则表示当前线程获取了锁，而公平锁则不一样，差异点

有两个

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);
    }
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        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;
}


/**
* Sync object for fair locks
*/
static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;
    final void lock() {
        acquire(1);
    }
    /**
     * 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;
    }
}