public class ExclusiveLock implements Lock {

    // 同步器，繼承自AQS
    private static class Sync extends AbstractQueuedSynchronizer {

        // 重寫獲取鎖的方式
        @Override
        protected boolean tryAcquire(int acquires) {
            assert acquires == 1;
            // cas的方式搶鎖
            if(compareAndSetState(0, 1)) {
                // 設(shè)置搶占鎖的線程為當(dāng)前線程
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        @Override
        protected boolean tryRelease(int releases) {
            assert releases == 1;

            if (getState() == 0) {
                throw new IllegalMonitorStateException();
            };
            //設(shè)置搶占鎖的線程為null
            setExclusiveOwnerThread(null);
            // 釋放鎖
            setState(0);
            return true;
        }
    }

    private final Sync sync = new Sync();

    @Override
    public void lock() {
        sync.acquire(1);
    }

    @Override
    public void unlock() {
        sync.release(1);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(time));
    }
    
    @Override
    public Condition newCondition() {
        return null;
    }
}

public static void main(String[] args) throws InterruptedException {
        ExclusiveLock exclusiveLock = new ExclusiveLock();


        new Thread(() -> {
            try {
                exclusiveLock.lock();
                System.out.println("thread1 get lock");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                exclusiveLock.unlock();
                System.out.println("thread1 release lock");
            }

        }).start();

        new Thread(() -> {
            try {
                exclusiveLock.lock();
                System.out.println("thread2 get lock");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                exclusiveLock.unlock();
                System.out.println("thread2 release lock");
            }

        }).start();

        Thread.currentThread().join();
    }

private transient volatile Node head;
private transient volatile Node tail;

static final class Node {
    //共享模式下的等待標(biāo)記
    static final Node SHARED = new Node();
    //獨(dú)占模式下的等待標(biāo)記
    static final Node EXCLUSIVE = null;
    //表示當(dāng)前結(jié)點(diǎn)已取消調(diào)度。當(dāng)timeout或被中斷（響應(yīng)中斷的情況下），會(huì)觸發(fā)變更為此狀態(tài)，進(jìn)入該狀態(tài)后的結(jié)點(diǎn)將不會(huì)再變化。
    static final int CANCELLED =  1;
    //表示后繼結(jié)點(diǎn)在等待當(dāng)前結(jié)點(diǎn)喚醒。后繼結(jié)點(diǎn)入隊(duì)時(shí)，會(huì)將前繼結(jié)點(diǎn)的狀態(tài)更新為SIGNAL。
    static final int SIGNAL    = -1;
    //表示結(jié)點(diǎn)等待在Condition上，當(dāng)其他線程調(diào)用了Condition的signal()方法后，CONDITION狀態(tài)的結(jié)點(diǎn)將從等待隊(duì)列轉(zhuǎn)移到同步隊(duì)列中，等待獲取同步鎖。
    static final int CONDITION = -2;
    //共享模式下，前繼結(jié)點(diǎn)不僅會(huì)喚醒其后繼結(jié)點(diǎn)，同時(shí)也可能會(huì)喚醒后繼的后繼結(jié)點(diǎn)。
    static final int PROPAGATE = -3;
    //狀態(tài)，包括上面的四種狀態(tài)值，初始值為0，一般是節(jié)點(diǎn)的初始狀態(tài)
    volatile int waitStatus;
    //上一個(gè)節(jié)點(diǎn)的引用
    volatile Node prev;
    //下一個(gè)節(jié)點(diǎn)的引用
    volatile Node next;
    //保存在當(dāng)前節(jié)點(diǎn)的線程引用
    volatile Thread thread;
    //condition隊(duì)列的后續(xù)節(jié)點(diǎn)
    Node nextWaiter;
}

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

//直接拋出異常，這是由子類進(jìn)行實(shí)現(xiàn)的方法，體現(xiàn)了模板模式的思想
protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}

// 將線程封裝成一個(gè)節(jié)點(diǎn)，放入同步隊(duì)列的尾部
private Node addWaiter(Node mode) {
    // 當(dāng)前線程封裝成同步隊(duì)列的一個(gè)節(jié)點(diǎn)Node
    Node node = new Node(Thread.currentThread(), mode);
    // 這個(gè)節(jié)點(diǎn)需要插入到原尾節(jié)點(diǎn)的后面，所以我們?cè)谶@里先記下原來的尾節(jié)點(diǎn)
    Node pred = tail;
    // 判斷尾節(jié)點(diǎn)是否為空，若為空表示隊(duì)列中還沒有節(jié)點(diǎn)，則不執(zhí)行以下步驟
    if (pred != null) {
        // 記錄新節(jié)點(diǎn)的前一個(gè)節(jié)點(diǎn)為原尾節(jié)點(diǎn)
        node.prev = pred;
        // 將新節(jié)點(diǎn)設(shè)置為新尾節(jié)點(diǎn)，使用CAS操作保證了原子性
        if (compareAndSetTail(pred, node)) {
            // 若設(shè)置成功，則讓原來的尾節(jié)點(diǎn)的next指向新尾節(jié)點(diǎn)
            pred.next = node;
            return node;
        }
    }
    // 若以上操作失敗，則調(diào)用enq方法繼續(xù)嘗試(enq方法見下面)
    enq(node);
    return node;
}

private Node enq(final Node node) {
    // 使用死循環(huán)不斷嘗試
    for (;;) {
        // 記錄原尾節(jié)點(diǎn)
        Node t = tail;
        // 若原尾節(jié)點(diǎn)為空，則必須先初始化同步隊(duì)列，初始化之后，下一次循環(huán)會(huì)將新節(jié)點(diǎn)加入隊(duì)列
        if (t == null) { 
            // 使用CAS設(shè)置創(chuàng)建一個(gè)默認(rèn)的節(jié)點(diǎn)作為首屆點(diǎn)
            if (compareAndSetHead(new Node()))
                // 首尾指向同一個(gè)節(jié)點(diǎn)
                tail = head;
        } else {
            // 以下操作與addWaiter方法中的if語句塊內(nèi)一致
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

final boolean acquireQueued(final Node node, int arg) {
    //標(biāo)記是否成功拿到資源
    boolean failed = true;
    try {
        //標(biāo)記等待過程中是否被中斷過
        boolean interrupted = false;

        //“自旋”！
        for (;;) {
            //拿到前驅(qū)
            final Node p = node.predecessor();
            //如果前驅(qū)是head，即該結(jié)點(diǎn)已成老二，那么便有資格去嘗試獲取資源（可能是老大釋放完資源喚醒自己的，當(dāng)然也可能被interrupt了）。
            if (p == head && tryAcquire(arg)) {
                //拿到資源后，將head指向該結(jié)點(diǎn)。所以head所指的標(biāo)桿結(jié)點(diǎn)，就是當(dāng)前獲取到資源的那個(gè)結(jié)點(diǎn)或null。
                setHead(node);
                // setHead中node.prev已置為null，此處再將head.next置為null，就是為了方便GC回收以前的head結(jié)點(diǎn)。也就意味著之前拿完資源的結(jié)點(diǎn)出隊(duì)了！
                p.next = null; 
                 // 成功獲取資源
                failed = false;
                //返回等待過程中是否被中斷過
                return interrupted;
            }

            //如果自己可以休息了，就通過park()進(jìn)入waiting狀態(tài)，直到被unpark()。
            // 如果不可中斷的情況下被中斷了，那么會(huì)從park()中醒過來，發(fā)現(xiàn)拿不到資源，從而繼續(xù)進(jìn)入park()等待。
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                //如果等待過程中被中斷過，哪怕只有那么一次，就將interrupted標(biāo)記為true
                interrupted = true;
        }
    } finally {
        if (failed)
             // 如果等待過程中沒有成功獲取資源（如timeout，或者可中斷的情況下被中斷了），那么取消結(jié)點(diǎn)在隊(duì)列中的等待。
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //拿到前驅(qū)的狀態(tài)
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        //如果已經(jīng)告訴前驅(qū)拿完號(hào)后通知自己一下，那就可以安心休息了
        return true;
    if (ws > 0) {
        /*
         * 如果前驅(qū)放棄了，那就一直往前找，直到找到最近一個(gè)正常等待的狀態(tài)，并排在它的后邊。
         * 注意：那些放棄的結(jié)點(diǎn)，由于被自己“加塞”到它們前邊，它們相當(dāng)于形成一個(gè)無引用鏈，稍后就會(huì)被保安大叔趕走了(GC回收)！
         */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
         //如果前驅(qū)正常，那就把前驅(qū)的狀態(tài)設(shè)置成SIGNAL，告訴它拿完號(hào)后通知自己一下。有可能失敗，人家說不定剛剛釋放完呢！
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

private final boolean parkAndCheckInterrupt() {
    // 調(diào)用park()使線程進(jìn)入waiting狀態(tài)
    LockSupport.park(this);
    //調(diào)用park()使線程進(jìn)入waiting狀態(tài)
    return Thread.interrupted();
}

static void selfInterrupt() {
        Thread.currentThread().interrupt();
    }

public final boolean release(int arg) {
	// 上邊自定義的tryRelease如果返回true，說明該鎖沒有被任何線程持有
	if (tryRelease(arg)) {
		// 獲取頭結(jié)點(diǎn)
		Node h = head;
		// 頭結(jié)點(diǎn)不為空并且頭結(jié)點(diǎn)的waitStatus不是初始化節(jié)點(diǎn)情況，解除線程掛起狀態(tài)
		if (h != null && h.waitStatus != 0)
			unparkSuccessor(h);
		return true;
	}
	return false;
}

protected boolean tryRelease(int arg) {
    throw new UnsupportedOperationException();
}

private void unparkSuccessor(Node node) {
	// 獲取頭結(jié)點(diǎn)waitStatus
	int ws = node.waitStatus;
	if (ws < 0)
		compareAndSetWaitStatus(node, ws, 0);
	// 獲取當(dāng)前節(jié)點(diǎn)的下一個(gè)節(jié)點(diǎn)
	Node s = node.next;
	// 如果下個(gè)節(jié)點(diǎn)是null或者下個(gè)節(jié)點(diǎn)被cancelled，就找到隊(duì)列最開始的非cancelled的節(jié)點(diǎn)
	if (s == null || s.waitStatus > 0) {
		s = null;
		// 就從尾部節(jié)點(diǎn)開始找，到隊(duì)首，找到隊(duì)列第一個(gè)waitStatus<0的節(jié)點(diǎn)。
		for (Node t = tail; t != null && t != node; t = t.prev)
			if (t.waitStatus <= 0)
				s = t;
	}
	// 如果當(dāng)前節(jié)點(diǎn)的下個(gè)節(jié)點(diǎn)不為空，而且狀態(tài)<=0，就把當(dāng)前節(jié)點(diǎn)unpark
	if (s != null)
		LockSupport.unpark(s.thread);
}

private Node addWaiter(Node mode) {
	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;
}