多线程基础(十五)：ReentrantLock源码分析

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

 private final Sync sync;

/**
 * Creates an instance of {@code ReentrantLock}.
 * This is equivalent to using {@code ReentrantLock(false)}.
 */
public ReentrantLock() {
    sync = new NonfairSync();
}

/**
 * Creates an instance of {@code ReentrantLock} with the
 * given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

/**
 * 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();
}

final boolean nonfairTryAcquire(int acquires) {
    //获取当前线程
    final Thread current = Thread.currentThread();
    //获取当前的state 到变量c
    int c = getState();
    //如果c为0 则说明当前的锁空闲
    if (c == 0) {
        //由于是非公平锁，只要判断c为0 ，则上来先抢锁，不管等待队列中是否有数据。
        //采用cas的方式set State，这个方法确保在并发的情况下只有一个线程能成功。
        if (compareAndSetState(0, acquires)) {
            //如果成功，则将锁的owner设置为当前线程
            setExclusiveOwnerThread(current);
            //直接返回为true
            return true;
        }
    }
    //如果不为0，且当前线程为此锁的Owner则说明是再次重入
    else if (current == getExclusiveOwnerThread()) {
       //将state的值加上acquires 通常是加1
        int nextc = c + acquires;
        //如果相加之后小于0 则说明字段溢出，此时抛出异常
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        //通过set方法修改状态
        setState(nextc);
        //返回成功
        return true;
    }
    //如果都不是，则返回获取锁失败，外层调用可能需要再次循环
    return false;
}

protected final boolean tryRelease(int releases) {
    //c为当前的state状态减去release 一般是减1
    int c = getState() - releases;
    //如果当前线程不是Owner 则抛出异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    //定义free为false
    boolean free = false;
    //如果c为0，则表示state完全释放了锁。
    if (c == 0) {
        free = true;
        //将锁的Owoner状态设置为null
        setExclusiveOwnerThread(null);
    }
    //设置状态为c  
    setState(c);
    //返回free的值
    return free;
}

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))
            //如果成功则设置线程为Owner
            setExclusiveOwnerThread(Thread.currentThread());
        else
            //如果没有竞争成功，则调用acquire进行入队，执行AQS通用操作
            acquire(1);
    }
    
    protected final boolean tryAcquire(int acquires) {
       //tryAcquire调用前面的nonfairTryAcquire方法
        return nonfairTryAcquire(acquires);
    }
}

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

    final void lock() {
    //注意此时与非公平锁的区别，此处直接执行acquire（1），而非公平锁一上来需要先竞争一次
        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();
        //如果c为0
        if (c == 0) {
            //如果队列中不具有前任节点，且能够cas抢锁成功，则设置owoner并返回true
            if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        //反之，如果锁的线程为当前线程
        else if (current == getExclusiveOwnerThread()) {
            //判断c相加之后是否越界
            int nextc = c + acquires;
            //为负数则说明越界 抛出异常
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            //set state的状态
            setState(nextc);
            //返回true
            return true;
        }
        //反之返回false
        return false;
    }
}

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