Java锁（二）ReentrantLock独占锁分析

ReentrantLock的功能是实现代码段的并发访问控制，是一种排它锁，也就是通常意义上所说的锁，内部有两种实现NonfairSync和FairSync，公平锁和非公平锁，默认采用非公平锁策略。ReentrantLock的实现不仅可以替代隐式的synchronized关键字，而且能够提供超过关键字本身的多种功能。

1、ReentrantLock的使用

class X {  private final ReentrantLock lock = new ReentrantLock();  // ...  public void m() {    lock.lock();  // block until condition holds    try {      // ... method body    } finally {      lock.unlock()    }  }}

ReentrantLock会保证method-body在同一时间只有一个线程在执行这段代码，或者说，同一时刻只有一个线程的lock方法会返回。其余线程会被挂起，直到获取锁。从这里可以看出，其实ReentrantLock实现的就是一个独占锁的功能：有且只有一个线程获取到锁，其余线程全部挂起，直到该拥有锁的线程释放锁，被挂起的线程被唤醒重新开始竞争锁。那现在看下Doug Lea 怎么去实现ReentrantLock重入锁的。首先看下ReentrantLock的创建和加锁、解锁过程。

2、ReentrantLock原理分析

/** * 默认非公平锁 */public ReentrantLock() {    sync = new NonfairSync();} /** * 创建ReentrantLock，公平锁or非公平锁*/public ReentrantLock(boolean fair) {    sync = fair ? new FairSync() : new NonfairSync();}/** *加锁解锁，使用sync完成*/public void lock() {    sync.lock();}public void unlock() {    sync.release(1);}

其中，公平锁中每个线程抢占锁的顺序为先后调用lock方法的顺序依次获取锁。非公平锁中每个线程抢占锁的顺序不定，先获取锁，获取不到，然后加入到queue中，和调用lock方法的先后顺序无关。

如果在绝对时间上，先对锁进行获取的请求一定被先满足，那么这个锁是公平的，反之，是不公平的，也就是说等待时间最长的线程最有机会获取锁，也可以说锁的获取是有序的。ReentrantLock这个锁提供了一个构造函数，能够控制这个锁是否是公平的。而锁的名字也是说明了这个锁具备了重复进入的可能，也就是说能够让当前线程多次的进行对锁的获取操作，这样的最大次数限制是Integer.MAX_VALUE，约21亿次左右。

事实上公平的锁机制往往没有非公平的效率高，因为公平的获取锁没有考虑到操作系统对线程的调度因素，这样造成JVM对于等待中的线程调度次序和操作系统对线程的调度之间的不匹配。对于锁的快速且重复的获取过程中，连续获取的概率是非常高的，而公平锁会压制这种情况，虽然公平性得以保障，但是响应比却下降了，但是并不是任何场景都是以TPS作为唯一指标的，因为公平锁能够减少“饥饿”发生的概率，等待越久的请求越是能够得到优先满足。

AQS的队列操作

在分析加锁前，先看下AQS的入队列操作， head，tail节点默认为null，入队列时，当tail为null时，初始化创建dummy head节点，将入队列的node插入队尾。

/** * Creates and enqueues node for given thread and mode. * 节点入同步队列，通过CAS比较然后插入队列尾部，  * @param current the thread * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared * @return the new node */private Node addWaiter(Node mode) {    Node node = new Node(Thread.currentThread(), mode);    // 快速入队列,tail不为null，通过CAS比较然后插入队列尾部 Node pred = tail;    if (pred != null) {        node.prev = pred;        if (compareAndSetTail(pred, node)) {            pred.next = node;            return node;        }    }    //快速入队列失败后执行enq方法    enq(node);    return node;}/** * 插入节点到队列中，必要的时候初始化头节点，返回该节点前驱 * @param node the node to insert * @return node's predecessor */private Node enq(final Node node) {    for (;;) {        Node t = tail;        if (t == null) { // 初始化，创建Dummy header，thread为null            if (compareAndSetHead(new Node()))                tail = head;        } else {            node.prev = t;            if (compareAndSetTail(t, node)) {                t.next = node;                return t;            }        }    }}

AQS获取锁定(独占锁)

调用acquire方法，其实这个方法是阻塞的, 获取锁的步骤为：

1、 tryAcquire（由子类Sync实现）尝试获取锁
2、 没有获取到锁，将节点加入到队列尾部中，加入成功selfInterrupt，中断当前线程。

public final void acquire(int arg)  { if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt();}

没有获取到锁则调用AQS的acquireQueued方法：

1、当node的前驱节点是头节点，并且独占时才返回
2、前继节点不是head, 而且当你的前继节点状态是Node.SIGNAL时， 你这个线程将被park()，直到另外的线程release时,发现head.next是你这个node时才unpark，才能继续循环并获取锁

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)) {                setHead(node);                p.next = null; // help GC，队列中移除头节点p                failed = false;                return interrupted;            }            /* 阻塞并判断是否打断，其实这个判断才是自旋锁真正的猥琐点，             * 意思是如果你的前继节点不是head,             * 而且当你的前继节点状态是Node.SIGNAL时，             * 你这个线程将被park()，             * 直到另外的线程release时,发现head.next是你这个node时，才unpark，             * 才能继续循环并获取锁             */            if (shouldParkAfterFailedAcquire(p, node) &&                parkAndCheckInterrupt())                interrupted = true;        }    } finally {        if (failed)            cancelAcquire(node);    }}

shouldParkAfterFailedAcquire这个方法删除所有waitStatus>0也就是CANCELLED状态的Node,并设置前继节点为signal

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {    int ws = pred.waitStatus;    if (ws == Node.SIGNAL)        /*         * 节点已经设置状态Node.SIGNAL，         * 请求释放使它获取信号，所以它才能安全的park         */        return true;    if (ws > 0) {        /*         *前驱节点被取消，跳过所有的取消的前驱节点和表明重试         */        do {            node.prev = pred = pred.prev;        } while (pred.waitStatus > 0);        pred.next = node;    } else {        /*         * waitStatus为0或者PROPAGATE,表明我们需要一个信号，但是还没有park，         * 调用者需要重试，保证在parking过程中，它不能被获取到         */        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);    }     return false;}/* 禁用当前线程，返回是否中断 */private final boolean parkAndCheckInterrupt() {    LockSupport.park(this);    return Thread.interrupted();}

独占锁acquire获取的过程，如下所示

AQS释放独占锁

1、tryRelease释放锁，没有释放成功，返回false
2、锁释放成功，唤醒head的后继节点，返回true

public final boolean release(int arg) {    if (tryRelease(arg)) {        Node h = head;        if (h != null && h.waitStatus != 0)            unparkSuccessor(h);//unblock，唤醒head的后继节点        return true;    }    return false;}private void unparkSuccessor(Node node) {    /*     * 状态为负数，清除信号，设置成0     */    int ws = node.waitStatus;    if (ws < 0)        compareAndSetWaitStatus(node, ws, 0);    /*     * 唤醒后继节点（一般是下一个节点)，如果节点被取消或者为null     * 反向遍历从尾到头找到实际的非取消的后继节点（问题：为什么不正向遍历）     */    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中公平锁和非公平锁

两种锁都继承Sync，而 Sync又继承AbstractQueuedSynchronizer ，所以子类必须实现AQS的5个保护方法。

对于独占锁，需要实现tryAcquire，tryRelease，isHeldExclusively这3个方法，

其中tryRelease，isHeldExclusively是公平锁和非公平锁共有的，在Sync中实现。

1、tryRelease尝试释放锁，每调用tryRelease(1)一次，将state减去1，当state为0的时候，释放锁成功，将独占锁的owner设为null。

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;}

2、isHeldExclusively判断独占锁的owner是不是当前线程

protected final boolean isHeldExclusively() {    return getExclusiveOwnerThread() == Thread.currentThread();}

非公平锁

现在我们来看NonfairSync加锁的策略

1、查看同步队列锁的state，不通过同步队列，通过CAS抢占独占锁，抢占成功，将当前线程设置成独占线程，state增加1。
2、获取不成功，走普通的获取锁的流程

final void lock() {    if (compareAndSetState(0, 1))        setExclusiveOwnerThread(Thread.currentThread());    else        acquire(1);}

其中NonfairSync在acquire 获取锁的过程中，调用tryAcquire尝试获取锁。

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

在看Sync的 nonfairTryAcquire方法实现如下，直接通过CAS获取锁

final boolean nonfairTryAcquire(int acquires) {    final Thread current = Thread.currentThread();    int c = getState();    /* 锁没有被占用，将当前线程设置成独占锁的owner */    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;}

公平锁

了解非公平锁的获取过程，我们再看下公平锁的加锁过程，了解其区别

final void lock() {    acquire(1);}

通过acquire获取锁，没有像非公平锁通过CAS操作，直接抢占独占锁。

protected final boolean tryAcquire(int acquires) {    final Thread current = Thread.currentThread();    int c = getState();    if (c == 0) {        /* hasQueuedPredecessors判断是否有比当前线程等待更久的线程在等待         * 没有的话则通过CAS获取锁         */        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;}

从上面的代码可以看出
1、 公平锁与非公平锁的释放锁步骤是一致的
2、获取锁的过程不一致，非公平锁是让当前线程优先独占，而公平锁则是让等待时间最长的线程优先，非公平的可能让其他线程没机会执行，而公平的则可以让等待时间最长的先执行，但是性能上会差点。