ReentrantLock lock = new ReentrantLock();
		//嘗試獲取鎖
        lock.lock();
        //獲得鎖后執(zhí)行邏輯......
        //......
		//解鎖
        lock.unlock();

    public ReentrantLock() {
        sync = new NonfairSync();
    }

final void lock() {
    if (compareAndSetState(0, 1))//【step1】
        setExclusiveOwnerThread(Thread.currentThread());//【step2】
    else
        acquire(1);//【step3】
}

protected final boolean compareAndSetState(int expect, int update) {
    // See below for intrinsics setup to support this
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

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

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        //如果此時state已經(jīng)變?yōu)?，再次嘗試一次獲取鎖
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        //否則判斷當前持有AQS的鎖的線程是不是當前請求獲取鎖的線程，是的話就進行鎖重入。
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

private Node addWaiter(Node mode) {
    //新建一個Node節(jié)點，mode傳入表示當前線程之間競爭是互斥模式
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    //嘗試添加當前新建Node到鏈表隊列末尾
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        //利用cas設置尾指針指向的節(jié)點為當前線新建節(jié)點
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    //當前是空的沒有任何正在等待的線程Node的時候，執(zhí)行enq(node)，初始化等待隊列
    enq(node);
    return node;
}

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            //新建一個空的頭節(jié)點
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            //跟之前一樣，利用cas這只當前新建節(jié)點為尾節(jié)點
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            //獲取當前競爭鎖的線程Node的前置節(jié)點
            final Node p = node.predecessor();
            //【step1】
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            //【step2】
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        //前置節(jié)點是-1，返回true表示線程可掛起
        return true;
    if (ws > 0) {
        //前置節(jié)點大于0表示前置節(jié)點已經(jīng)取消，那么進行跳過前置節(jié)點的操作，做鏈表的基本刪除節(jié)點操作
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        //如果前置節(jié)點還是0,表示前置節(jié)點Node的waitStatus是初始值，需要設置為-1，然后外層循環(huán)重新執(zhí)行shouldParkAfterFailedAcquire方法，即可掛起當前線程。
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

private final boolean parkAndCheckInterrupt() {
    //阻塞掛起線程，等待喚醒
    LockSupport.park(this);
    //喚醒后，重置中斷標記，線程中斷標記位為不中斷
    return Thread.interrupted();
}

final void lock() {
    acquire(1);
}

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();
    int c = getState();
    if (c == 0) {
        //hasQueuedPredecessors判斷隊列是否還有別的線程在等待鎖，沒有的話就嘗試獲取lock
        //如果有別的線程在等待鎖，就不會嘗試獲取lock；下面如果也不是重入的情況的話就直接進入等待隊列
        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;
}

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

protected final boolean tryRelease(int releases) {
    //獲取state減掉realease，對于ReentrantLock就是默認減一
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        //如果減到0了，那么久釋放鎖
        free = true;
        //設置持有線程為null
        setExclusiveOwnerThread(null);
    }
    //設置state為新的
    setState(c);
    return free;
}

    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();