JUC源码分析9-locks-ReentrantLock

ReentrantLock可重入锁，使用比synchronized方便灵活，可作为替代使用：

1.支持公平/不公平锁；

2.支持响应超时，响应中断；

3.支持condition；

ReentrantLock实现了Lock接口，内部使用static类继承AQS实现独占式的api来实现这些功能，使用AQS的state来表示锁可重入次数：

之前学习AQS的时候说过请求和release的大的流程：

acquire：

if(!tryacquire())

加入AQS的等待队列

release:

if(tryrelease)

unpark等待队列的节点

先看下内部类的实现：

<span style="font-size:18px;">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();

    /**
			非公平锁的acquire
     */
    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        //判断state是否被占用
        if (c == 0) {
        //没有被占用，直接cas占用，成功的话就设置当前线程为占用线程
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        //如果state不为0,因为是可重入锁，需要判断是不是自己占用的，如果是累加state值
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        //acquire失败，AQS等待队列排队
        return false;
    }
		//release的时候也需要判断是不是当前线程。因为可重入，所以可以lock多次，release的时候就要release多次
    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;
    }
		/**AbstractOwnableSynchronizer.exclusiveOwnerThread 判断是否为当前占用lock的线程*/
    protected final boolean isHeldExclusively() {
        // While we must in general read state before owner,
        // we don't need to do so to check if current thread is owner
        return getExclusiveOwnerThread() == Thread.currentThread();
    }
		/**lock.newCondition每次直接new一个AQS的conditionObject维护一个条件队列*/
    final ConditionObject newCondition() {
        return new ConditionObject();
    }

    // Methods relayed from outer class

    final Thread getOwner() {
        return getState() == 0 ? null : getExclusiveOwnerThread();
    }

    final int getHoldCount() {
        return isHeldExclusively() ? getState() : 0;
    }

    final boolean isLocked() {
        return getState() != 0;
    }

    /**
     * Reconstitutes this lock instance from a stream.
     * @param s the stream
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
    }
}</span>

内部类实现了AQS独占api的tryRelease，看下公平和非公平锁的tryAcquire实现：

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**非公平锁进来就cas，成功就设置独占线程，不成功再去Acquire排队，这就是公平不公平的区分*/
    final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }
		/**直接使用父类中notFairAcquire*/
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {
        acquire(1);
    }
		/**公平锁的tryAcquire*/
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
        		//锁还在并且AQS没有其他等待节点，cas设置，然后再设置独占线程
            if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        else if (current == getExclusiveOwnerThread()) {
        //因为是可重入锁，state不为0看是不是自己占用了，如果是更新state值
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }
}
//判断队列没有其他等待节点
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 &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

看下ReentrantLock对lock接口的实现和构造方法：

ublic ReentrantLock() {
    sync = new NonfairSync();
}

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

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

public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}

public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}

public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

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

public Condition newCondition() {
    return sync.newCondition();
}

默认是非公平锁，也可以传入参数明确要求采用公平还是非公平锁。对接口实现基本上都是调用AQS的东西。

基本来看出来ReetrantLock的公平和非公平的区分就是在Acquire的时候，非公平会先直接尝试cas修改，不成功再去排队，就是插队，而公平锁就是老老实实请求排队操作。

ReetrantLock还有其他一些监控方法，如isLocked等，没什么东西。