//Lock接口下的方法
public interface Lock {
    //阻塞式搶占鎖，如果搶到鎖，則向下執(zhí)行程序；搶占失敗線程阻塞，直到釋放鎖才會進行搶占鎖
    void lock();
    //可中斷模式搶占鎖，線程調(diào)用此方法能夠中斷線程
    void lockInterruptibly() throws InterruptedException;
    //非阻塞式嘗試獲取鎖，調(diào)用此方法線程不會阻塞，搶到鎖返回true，失敗返回false
    boolean tryLock();
    //在指定時間內(nèi)嘗試獲取鎖，在指定時間內(nèi)搶到鎖成功返回true，失敗返回false
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    //釋放鎖，線程執(zhí)行完程序后，調(diào)用此方法來釋放鎖資源
    void unlock();
    //條件隊列
    Condition newCondition();
    }

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

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

        final void lock() {
            acquire(1);
        }
        /*這里將acquire方法放于此
            public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
        */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            //拿到當前鎖對象的狀態(tài)
            int c = getState();
            //如果沒有線程獲取到鎖
            if (c == 0) {
                //首先會判斷是否有前驅節(jié)點，如果沒有就會調(diào)用CAS機制更新鎖對象狀態(tài)
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    //設置當前線程擁有鎖資源
                    setExclusiveOwnerThread(current);
                    //如果獲取鎖資源成功則返回true
                    return true;
                }
            }
            //或者如果拿到鎖的就是當前線程
            else if (current == getExclusiveOwnerThread()) {
                //將鎖的狀態(tài)+1，考慮到鎖重入
                int nextc = c + acquires;
                if (nextc < 0)
                    //超過了最大鎖的數(shù)量
                    throw new Error("Maximum lock count exceeded");
                //如果鎖數(shù)量沒有溢出，設置當前鎖狀態(tài)
                setState(nextc);
                //如果成功獲取鎖資源則返回true
                return true;
            }
            //如果前兩條都不符合，則返回false
            return false;
        }
    }

    public final boolean hasQueuedPredecessors() {
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
        //h!=t，首節(jié)點不等于尾節(jié)點表示隊列中有節(jié)點
        return h != t &&
            (
            //s為頭結點的下一個節(jié)點，返回false表示隊列中還有第二個節(jié)點，或運算符后面表示，第二個線程不是當前線程
            (s = h.next) == null || s.thread != Thread.currentThread()
            );
    }

    //第一種方式，默認實現(xiàn)
    public ReentrantLock() {
        sync = new NonfairSync();
    }
    //第二種方式，傳入false來創(chuàng)建非公平鎖對象
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

    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))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(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;
        }