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

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) { //空轉(zhuǎn)，自旋
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) { //如果當(dāng)前是頭節(jié)點，繼續(xù)嘗試獲取鎖，這也就是為啥只有頭節(jié)點才有意義
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
		//如果不是繼續(xù)等待
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private Node addWaiter(Node mode) {
	//把當(dāng)前線程改造稱為Node，
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

public class MyLock implements Lock {
    private Helper helper = new Helper();
    //按照官方文檔所說，構(gòu)建內(nèi)部幫助類
    private class Helper extends AbstractQueuedSynchronizer {
        //構(gòu)建嘗試獲取鎖的方法
        @Override
        protected boolean tryAcquire(int arg) {
            int state = getState();
            if (0 == state) {
                //利用cas的原理修改state
                if (compareAndSetState(0, arg)) {
                    //設(shè)置當(dāng)前線程擁有資源
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }
            }//同一個線程獲取被鎖住的資源時，直接分配給這個線程，實現(xiàn)可重入性
            else if(getExclusiveOwnerThread()==Thread.currentThread()){ //刪除這個else if條件，就會變?yōu)橐粋€不可重入鎖
                setState(getState()+arg);
                return true;
            }
            return false;
        }
        //構(gòu)建嘗試釋放鎖的方法
        @Override
        protected boolean tryRelease(int arg) {
            //arg是傳遞進(jìn)來的state的期望值
            int state = getState() - arg;
            //判斷釋放后狀態(tài)是否為0
            if (0 == state) {
                setExclusiveOwnerThread(null);
                setState(0);
                return true;
            }
            //因為需要修改的線程就是當(dāng)前占有鎖的線程，所以此時直接重置是沒有線程安全問題的，也就是當(dāng)前線程獨占了資源state
            setState(state);
            return false;
        }
        public Condition newConditionObject(){
            return new ConditionObject();
        }
    }
    //加鎖方法
    @Override
    public void lock() {
        helper.acquire(1); //AbstractQueuedSynchronizer原生方法
    }
    //鎖中斷
    @Override
    public void lockInterruptibly() throws InterruptedException {
        helper.acquireInterruptibly(1); //AbstractQueuedSynchronizer原生方法
    }
	//嘗試獲取鎖
    @Override
    public boolean tryLock() {
        return helper.tryAcquire(1); //使用自己實現(xiàn)的tryAcquire()方法
    }
    //嘗試加鎖
    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return helper.tryAcquireNanos(1,unit.toNanos(time)); //AbstractQueuedSynchronizer原生方法
    }
	//釋放鎖
    @Override
    public void unlock() {
        helper.tryRelease(1);  //使用自己實現(xiàn)的tryRelease()方法
    }
	//條件
    @Override
    public Condition newCondition() {
        return helper.newConditionObject(); //AbstractQueuedSynchronizer原生方法
    }
}