ReentrantLock 分析

public class ReentrantLock implements Lock, java.io.Serializable

/**
 * 获取锁 由于公平锁和非公平锁  获取锁的动作 不一样，所以留着让子类实现更好。
 */
abstract void lock();

/**
 * 非公平模式下尝试获取锁。两种情况：
 *   1. 锁没被占用：
 *   (1). CAS将当前锁状态加1
 *   (2). 将当前线程设置为锁的独享者。
 *  2. 锁被占用
 *   (1). 如果锁占用者是当前线程 ，则将线程状态加+1 ，通过这个线程状态 就可以知道重入次数
 */
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;
}

/***
 *  第一步：依次减去释放量(releases变量 这里都是1)，
 *  第二步：如果全部释放(state)，则将锁占用者置为null，表示释放锁。
 * @param releases
 * @return
 */
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;
}

/**
 *  判断当前线程是否是锁的拥有者
 * @return
 */
protected final boolean isHeldExclusively() {
    return getExclusiveOwnerThread() == Thread.currentThread();
}

/**
 * 查看当前线程重入次数
 * @return
 */
final int getHoldCount() {
    return isHeldExclusively() ? getState() : 0;
}

/**
 * 当前锁是否被占用
 * @return
 */
final boolean isLocked() {
    return getState() != 0;
}

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

    /**
     * 1. 英文版 注释：
     * Performs lock.  Try immediate barge, backing up to normal
     * acquire on failure.
     *
     * 我的谬论:
     *  barge 在英文中是: 蛮不讲理地闯入或打扰某事物 、闯入之意。( 用在此场景，个人感觉很好呀 ^_^ )
     *  加锁过程：当一个线程调用lock方法时，直接尝试加锁，如果加锁失败，再进行正常的获取。
     *  从这里可以看出 作者认为 ReentrantLock更多的时候，锁的争抢并不激烈，大多时候第一次的barge就能获取锁，所以作者才会首先进行barge，失败再尝试正常获取。
     */
    final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

    /**
     * lock 中的 acquire(1) 代码段可能会调用此方法 , 此方法的作用主要是为了 获取独占锁 , 获取失败的线程将会进入等待队列
     * @param acquires
     * @return
     */
    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);
        }

        /**
         * 尝试获取独占锁. 两种情况:
         *  1. 锁未被占用(state = 0 )
         *    如果等待队列为空 或当前线程时等待队列首个出队线程 则尝试获取锁.
         *  2. 锁被占用(state != 0)
         *    校验当前线程是否已经拥有独占锁，如果是，则记录重入次数。
         * @param acquires
         * @return
         */
        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;
        }
    }

int c = getState();
if (c == 0) {
    if (compareAndSetState(0, acquires)) {
        setExclusiveOwnerThread(current);
        return true;
    }
}

int c = getState() - releases;

boolean free = false;
if (c == 0) {
    free = true;
    setExclusiveOwnerThread(null);
}
setState(c);

return free;