java多线程随手记——ReentrantLock的公平锁与非公平锁

         ReentrantLock是concurrent包中，实现的一个锁，下面，我们将对其源码进行分析，以期获得更为有价值的内容。

         我们可以按照ReentrantLock的使用方式，来慢慢解析其源码构成。

         正如上一章Java多线程随手记——各种锁中的CODE使用的方式，首先我们需要初始化ReentrantLock对象。

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

         从这里可以看到，ReentrantLock实现了公平锁和非公平锁两种方式，首先，我们先把两种实现的思路描述下，然后再看具体实现。

         公平锁：看名字就特别和谐，大家都一起排队WC，队伍中轮到谁了谁就去。

         非公平锁：这就是特别暴力了，大家都憋不住，队伍排是排，但是只要厕所里的人一出来，不管队伍顺序，靠拳头说话，谁抢到了算谁的。

         接下来，我们开始着手具体实现。

         公平锁：

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

         首先，看看state是否为0，也就是占用线程已经全部unlock掉，那么再看看自己是不是处于队列的第一个，compareAndSetState()同时检查占用状态，并且修改state值(这是一个底层的CAS原子操作，我是把它理解为类似操作系统中的P操作)。current == getExclusiveOwnerThread()后面便是完成了可重入锁的功效了，当前线程进入lock再这之上再加锁+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;
        }

       这个非公平锁就野蛮的很，只要看到C为0了，就开抢，不管自己队列顺序，直接做CAS操作,谁先抢到谁就把state这门给关了，让别人进不来。

  下面，我们回头看看调用tryAcquire 的acquire方法

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

可以看到不管公平锁还是非公平锁，都是如果无法获取到当前锁，那么将进入队列中，同时如果满足阻塞条件，那么该线程将会被interrupt掉，直到等待被唤醒。

AbstractQueuedSynchronized 这个类的实现还是挺复杂的，同时它为了该Queue可以并发使用了一个双重检测的设计，打算新开个章节来详细叙述。

 

下一章节：AbstractQueuedSynchronized类源码分析