private Lock lock = new ReentrantLock();
public void test(){
    lock.lock();
    try{
        doSomeThing();
    }catch (Exception e){
        // ignored
    }finally {
        lock.unlock();
    }
}

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

final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

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

tryAcquire(arg)
final boolean nonfairTryAcquire(int acquires) {
    //獲取當(dāng)前線程
    final Thread current = Thread.currentThread();
    //獲取state變量值
    int c = getState();
    if (c == 0) { //沒(méi)有線程占用鎖
        if (compareAndSetState(0, acquires)) {
            //占用鎖成功,設(shè)置獨(dú)占線程為當(dāng)前線程
            setExclusiveOwnerThread(current);
            return true;
        }
    } else if (current == getExclusiveOwnerThread()) { //當(dāng)前線程已經(jīng)占用該鎖
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        // 更新state值為新的重入次數(shù)
        setState(nextc);
        return true;
    }
    //獲取鎖失敗
    return false;
}

/**
 * 將新節(jié)點(diǎn)和當(dāng)前線程關(guān)聯(lián)并且入隊(duì)列
 * @param mode 獨(dú)占/共享
 * @return 新節(jié)點(diǎn)
 */
private Node addWaiter(Node mode) {
    //初始化節(jié)點(diǎn),設(shè)置關(guān)聯(lián)線程和模式(獨(dú)占 or 共享)
    Node node = new Node(Thread.currentThread(), mode);
    // 獲取尾節(jié)點(diǎn)引用
    Node pred = tail;
    // 尾節(jié)點(diǎn)不為空,說(shuō)明隊(duì)列已經(jīng)初始化過(guò)
    if (pred != null) {
        node.prev = pred;
        // 設(shè)置新節(jié)點(diǎn)為尾節(jié)點(diǎn)
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 尾節(jié)點(diǎn)為空,說(shuō)明隊(duì)列還未初始化,需要初始化head節(jié)點(diǎn)并入隊(duì)新節(jié)點(diǎn)
    enq(node);
    return node;
}

/**
 * 初始化隊(duì)列并且入隊(duì)新節(jié)點(diǎn)
 */
private Node enq(final Node node) {
    //開(kāi)始自旋
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            // 如果tail為空,則新建一個(gè)head節(jié)點(diǎn),并且tail指向head
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            // tail不為空,將新節(jié)點(diǎn)入隊(duì)
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

/**
 * 已經(jīng)入隊(duì)的線程嘗試獲取鎖
 */
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true; //標(biāo)記是否成功獲取鎖
    try {
        boolean interrupted = false; //標(biāo)記線程是否被中斷過(guò)
        for (;;) {
            final Node p = node.predecessor(); //獲取前驅(qū)節(jié)點(diǎn)
            //如果前驅(qū)是head,即該結(jié)點(diǎn)已成老二，那么便有資格去嘗試獲取鎖
            if (p == head && tryAcquire(arg)) {
                setHead(node); // 獲取成功,將當(dāng)前節(jié)點(diǎn)設(shè)置為head節(jié)點(diǎn)
                p.next = null; // 原h(huán)ead節(jié)點(diǎn)出隊(duì),在某個(gè)時(shí)間點(diǎn)被GC回收
                failed = false; //獲取成功
                return interrupted; //返回是否被中斷過(guò)
            }
            // 判斷獲取失敗后是否可以掛起,若可以則掛起
            if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                // 線程若被中斷,設(shè)置interrupted為true
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

/**
 * 判斷當(dāng)前線程獲取鎖失敗之后是否需要掛起.
 */
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //前驅(qū)節(jié)點(diǎn)的狀態(tài)
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        // 前驅(qū)節(jié)點(diǎn)狀態(tài)為signal,返回true
        return true;
    // 前驅(qū)節(jié)點(diǎn)狀態(tài)為CANCELLED
    if (ws > 0) {
        // 從隊(duì)尾向前尋找第一個(gè)狀態(tài)不為CANCELLED的節(jié)點(diǎn)
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 將前驅(qū)節(jié)點(diǎn)的狀態(tài)設(shè)置為SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}
/**
 * 掛起當(dāng)前線程,返回線程中斷狀態(tài)并重置
 */
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

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

/** * 釋放當(dāng)前線程占用的鎖 * @param releases * @return 是否釋放成功 */protected final boolean tryRelease(int releases) {    // 計(jì)算釋放后state值    int c = getState() - releases;    // 如果不是當(dāng)前線程占用鎖,那么拋出異常    if (Thread.currentThread() != getExclusiveOwnerThread())        throw new IllegalMonitorStateException();    boolean free = false;    if (c == 0) {        // 鎖被重入次數(shù)為0,表示釋放成功        free = true;        // 清空獨(dú)占線程        setExclusiveOwnerThread(null);    }    // 更新state值    setState(c);    return free;}/**
 * 釋放當(dāng)前線程占用的鎖
 * @param releases
 * @return 是否釋放成功
 */
protected final boolean tryRelease(int releases) {
    // 計(jì)算釋放后state值
    int c = getState() - releases;
    // 如果不是當(dāng)前線程占用鎖,那么拋出異常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        // 鎖被重入次數(shù)為0,表示釋放成功
        free = true;
        // 清空獨(dú)占線程
        setExclusiveOwnerThread(null);
    }
    // 更新state值
    setState(c);
    return free;
}

 public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

public final boolean tryAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    return tryAcquire(arg) ||
        doAcquireNanos(arg, nanosTimeout);
}

/**
 * 在有限的時(shí)間內(nèi)去競(jìng)爭(zhēng)鎖
 * @return 是否獲取成功
 */
private boolean doAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    // 起始時(shí)間
    long lastTime = System.nanoTime();
    // 線程入隊(duì)
    final Node node = addWaiter(Node.EXCLUSIVE);
    boolean failed = true;
    try {
        // 又是自旋!
        for (;;) {
            // 獲取前驅(qū)節(jié)點(diǎn)
            final Node p = node.predecessor();
            // 如果前驅(qū)是頭節(jié)點(diǎn)并且占用鎖成功,則將當(dāng)前節(jié)點(diǎn)變成頭結(jié)點(diǎn)
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return true;
            }
            // 如果已經(jīng)超時(shí),返回false
            if (nanosTimeout <= 0)
                return false;
            // 超時(shí)時(shí)間未到,且需要掛起
            if (shouldParkAfterFailedAcquire(p, node) &&
                    nanosTimeout > spinForTimeoutThreshold)
                // 阻塞當(dāng)前線程直到超時(shí)時(shí)間到期
                LockSupport.parkNanos(this, nanosTimeout);
            long now = System.nanoTime();
            // 更新nanosTimeout
            nanosTimeout -= now - lastTime;
            lastTime = now;
            if (Thread.interrupted())
                //相應(yīng)中斷
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}