public class SynchronizedTest {
    public static void main(String[] args) {
        test1();
        test2();
    }

    // 使用synchronized修飾的方法
    public synchronized static void test1() {
        System.out.println("SynchronizedTest.test1");
    }

    // 使用synchronized修飾的代碼塊
    public static void test2() {
        synchronized (SynchronizedTest.class) {
            System.out.println("SynchronizedTest.test2");
        }
    }
}

// 省略啰嗦的代碼
public class cn.zq.sync.SynchronizedTest
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
{
  // 源碼
  public cn.zq.sync.SynchronizedTest();
    descriptor: ()V
    flags: ACC_PUBLIC
  // main 方法
  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC

  // synchronized 修飾的靜態(tài)方法 test1()
  public static synchronized void test1();
    descriptor: ()V
    // 在這里我們可以看到 flags 中有一個(gè) ACC_SYNCHRONIZED
    // 這個(gè)就是一個(gè)標(biāo)記符這是 保證原子性的關(guān)鍵
    // 當(dāng)方法調(diào)用的時(shí)候，調(diào)用指令將會(huì)檢查方法的 ACC_SYNCHRONIZED 訪問(wèn)標(biāo)記符是否被設(shè)置
    // 如果設(shè)置了，線程將先獲取 monitor，獲取成功之后才會(huì)執(zhí)行方法體，方法執(zhí)行之后，釋放monitor
    // 在方法執(zhí)行期間，其他任何線程都無(wú)法在獲得一個(gè) monitor 對(duì)象，本質(zhì)上沒(méi)區(qū)別。
    flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #5                  // String SynchronizedTest.test1
         5: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 17: 0
        line 18: 8

  // 代碼塊使用的 synchronized
  public static void test2();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=0
         0: ldc           #7                  // class cn/zq/sync/SynchronizedTest
         2: dup
         3: astore_0
         // 這個(gè) monitorenter 是一個(gè)指令
         // 每個(gè)對(duì)象都有一個(gè)監(jiān)視器鎖(monitor)，當(dāng)monitor被占用的時(shí)候就會(huì)處于鎖定狀態(tài)
         // 線程執(zhí)行monitorenter的時(shí)候，嘗試獲取monitor的鎖。過(guò)程如下
         // 1.任何monitor進(jìn)入數(shù)為0，則線程進(jìn)入并設(shè)置為1，此線程就是monitor的擁有者
         // 2.如果線程已經(jīng)占用，當(dāng)前線程再次進(jìn)入的時(shí)候，會(huì)將monitor的次數(shù)+1
         // 3.如何其他的線程已經(jīng)占用了monitor，則線程進(jìn)阻塞狀態(tài)，直到monitor的進(jìn)入數(shù)為0
         // 4.此時(shí)其他線程才能獲取當(dāng)前代碼塊的執(zhí)行權(quán)
         4: monitorenter
         5: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
         8: ldc           #8                  // String SynchronizedTest.test2
        10: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        13: aload_0
        // 執(zhí)行monitorexit這條指令的線程必須是擁有monitor的
        // 執(zhí)行的之后，monitor的進(jìn)入數(shù)-1.如果為0，那么線程就退出 monitor，不再是此代碼塊的執(zhí)行者
        // 此時(shí)再由其他的線程獲得所有權(quán)
        // 其實(shí) wait/notify 等方法也依賴(lài)于monitor對(duì)象，
        // 所以只有在同步方法或者同步代碼塊中才可以使用，否則會(huì)報(bào)錯(cuò) java.lang.IllegalMonitorstateException 異常
        14: monitorexit
        15: goto          23
        18: astore_1
        19: aload_0
        20: monitorexit
        21: aload_1
        22: athrow
        23: return
      Exception table:
         from    to  target type
             5    15    18   any
            18    21    18   any
      LineNumberTable:
        line 21: 0
        line 22: 5
        line 23: 13
        line 24: 23
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 18
          locals = [ class java/lang/Object ]
          stack = [ class java/lang/Throwable ]
        frame_type = 250 /* chop */
          offset_delta = 4
}
SourceFile: "SynchronizedTest.java"

public class ReentrantLock implements Lock, java.io.Serializable {

    // 鎖的類(lèi)型
    private final Sync sync;
    
    // 抽象靜態(tài)類(lèi)Sync繼承了AbstractQueueSynchroniser [這個(gè)在下面進(jìn)行解釋]
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        // 抽象加鎖方法
        abstract void lock();

        // 不公平的 tryLock 也就是不公平的嘗試獲取
        final boolean nonfairTryAcquire(int acquires) {
            // 獲取當(dāng)前線程對(duì)象
            final Thread current = Thread.currentThread();
            // 獲取線程的狀態(tài)
            int c = getState();
            // 根據(jù)線程的不同狀態(tài)執(zhí)行不同的邏輯
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            // 獲取獨(dú)占模式的線程的當(dāng)前鎖的狀態(tài)
            else if (current == getExclusiveOwnerThread()) {
                // 獲取新的層級(jí)大小
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                // 設(shè)置鎖的狀態(tài)
                setState(nextc);
                return true;
            }
            return false;
        }

        // 嘗試釋放方法
        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

        // 返回當(dāng)前線程是不是獨(dú)占的
        protected final boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        // 返回 ConditionObject 對(duì)象
        final ConditionObject newCondition() {
            return new ConditionObject();
        }

        // 獲得獨(dú)占的線程
        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

        // 獲得獨(dú)占線程的狀態(tài)
        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }

        // 判斷是否是加鎖的
        final boolean isLocked() {
            return getState() != 0;
        }

        // 序列化
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); 
        }
    }

    // 非公平鎖繼承了Sync
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        // 加鎖操作
        final void lock() {
            // 判斷是不是第一次加鎖 底層調(diào)用 Unsafe的compareAndSwapInt()方法
            if (compareAndSetState(0, 1))
                // 設(shè)置為獨(dú)占鎖
                setExclusiveOwnerThread(Thread.currentThread());
            // 如果不是第一次加鎖，則調(diào)用 acquire 方法在加一層鎖
            else
                acquire(1);
        }

        // 返回嘗試加鎖是否成功
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }
    
    // 公平鎖
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        // 加鎖操作，直接設(shè)置為1
        final void lock() {
            acquire(1);
        }

        // 嘗試加鎖
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                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 interface Lock {
    // 加鎖
    void lock();
    // 不斷加鎖
    void lockInterruptibly() throws InterruptedException;
    // 嘗試加鎖
    boolean tryLock();
    // 嘗試加鎖，具有超時(shí)時(shí)間
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    // 釋放鎖
    void unlock();
    // Condition 對(duì)象
    Condition newCondition();
}

public interface Condition {
    // 等待
    void await() throws InterruptedException;
    // 超時(shí)等待
    boolean await(long time, TimeUnit unit) throws InterruptedException;
    // 超時(shí)納秒等待
    long awaitNanos(long nanosTimeout) throws InterruptedException;
    // 可中斷等待
    void awaitUninterruptibly();
    // 等待死亡
    boolean awaitUntil(Date deadline) throws InterruptedException;
    // 指定喚醒
    void signal();
    // 喚醒所有
    void signalAll();
}

public class ReentrantLock implements Lock, java.io.Serializable {

    // 鎖的類(lèi)型
    private final Sync sync;

    // 默認(rèn)是非公平鎖
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    // 有參構(gòu)造，可以設(shè)置鎖的類(lèi)型
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

    // 加鎖
    public void lock() {
        sync.lock();
    }

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

    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }
    public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }
    // 解鎖 調(diào)用release() 因?yàn)槭侵厝腈i，所以需要減少重入的層數(shù)
    public void unlock() {
        sync.release(1);
    }

    // 返回Condition對(duì)象 ，用來(lái)執(zhí)行線程的喚醒等待等操作
    public Condition newCondition() {
        return sync.newCondition();
    }

    // 獲取鎖的層數(shù)
    public int getHoldCount() {
        return sync.getHoldCount();
    }

    public boolean isHeldByCurrentThread() {
        return sync.isHeldExclusively();
    }
    // 是否加鎖
    public boolean isLocked() {
        return sync.isLocked();
    }
    // 是否是公平鎖
    public final boolean isFair() {
        return sync instanceof FairSync;
    }
    // 獲取獨(dú)占鎖
    protected Thread getOwner() {
        return sync.getOwner();
    }
    // 查詢(xún)是否有任何線程正在等待獲取此鎖
    public final boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }
    // 查詢(xún)給定線程是否正在等待獲取此鎖
    public final boolean hasQueuedThread(Thread thread) {
        return sync.isQueued(thread);
    }
    // 獲取隊(duì)列的長(zhǎng)度
    public final int getQueueLength() {
        return sync.getQueueLength();
    }
    // 返回一個(gè)包含可能正在等待獲取該鎖的線程的集合
    protected Collection<Thread> getQueuedThreads() {
        return sync.getQueuedThreads();
    }

    // 判斷是否等待
    public boolean hasWaiters(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
    }
    
    // 獲得等待隊(duì)列的長(zhǎng)度
    public int getWaitQueueLength(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    // 獲取正在等待的線程集合
    protected Collection<Thread> getWaitingThreads(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
    }
    
    // toString()
    public String toString() {
        Thread o = sync.getOwner();
        return super.toString() + ((o == null) ?
                                   "[Unlocked]" :
                                   "[Locked by thread " + o.getName() + "]");
    }
}

public abstract class AbstractOwnableSynchronizer
    implements java.io.Serializable {

    private static final long serialVersionUID = 3737899427754241961L;

    protected AbstractOwnableSynchronizer() { }

    // 獨(dú)占模式當(dāng)前的擁有者
    private transient Thread exclusiveOwnerThread;

    // 設(shè)置獨(dú)占模式當(dāng)前的擁有者
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }

    // 得到獨(dú)占模式當(dāng)前的擁有者
    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
}

public abstract class AbstractQueuedSynchronizer    extends AbstractOwnableSynchronizer implements java.io.Serializable {

    private static final long serialVersionUID = 7373984972572414691L;

    protected AbstractQueuedSynchronizer() { }

    // AbstractQueueSynchronizer 中的靜態(tài)內(nèi)部類(lèi) Node 節(jié)點(diǎn)
    static final class Node {

        // 指示節(jié)點(diǎn)正在以共享模式等待的標(biāo)記
        static final Node SHARED = new Node();

        // 指示節(jié)點(diǎn)正在以獨(dú)占模式等待的標(biāo)記
        static final Node EXCLUSIVE = null;

        // 表示線程已經(jīng)取消
        static final int CANCELLED =  1;

        // 表示線程之后需要釋放
        static final int SIGNAL    = -1;

        // 表示線程正在等待條件
        static final int CONDITION = -2;

        // 指示下一個(gè) acquireShared 應(yīng)該無(wú)條件傳播
        static final int PROPAGATE = -3;

        // 狀態(tài)標(biāo)記
        volatile int waitStatus;

        // 隊(duì)列的前一個(gè)節(jié)點(diǎn)
        volatile Node prev;

        // 隊(duì)列的后一個(gè)節(jié)點(diǎn)
        volatile Node next;

        // 線程
        volatile Thread thread;

        // 下一個(gè)正在等待的節(jié)點(diǎn)
        Node nextWaiter;

        // 判斷是否時(shí)共享的
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        // 返回上一個(gè)節(jié)點(diǎn)，不能為null，為null拋出空指針異常
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }

        // 構(gòu)造
        Node() {    // Used to establish initial head or SHARED marker
        }

        // 有參構(gòu)造，用來(lái)添加線程的隊(duì)列
        Node(Thread thread, Node mode) {     // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }

        // 有參構(gòu)造，根據(jù)等待條件使用
        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

    // 頭節(jié)點(diǎn)
    private transient volatile Node head;

    // 尾節(jié)點(diǎn)
    private transient volatile Node tail;
    // 狀態(tài)
    private volatile int state;

    // 獲取當(dāng)前的狀態(tài)
    protected final int getState() {
        return state;
    }

    //設(shè)置當(dāng)前的狀態(tài)
    protected final void setState(int newState) {
        state = newState;
    }

    // 比較設(shè)置當(dāng)前的狀態(tài)
    protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

    // 納秒數(shù)，使之更快的旋轉(zhuǎn)
    static final long spinForTimeoutThreshold = 1000L;

    // 將節(jié)點(diǎn)插入隊(duì)列
    private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

    // 加一個(gè)等待節(jié)點(diǎn)
    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

    // 設(shè)置頭節(jié)點(diǎn)
    private void setHead(Node node) {
        head = node;
        node.thread = null;
        node.prev = null;
    }

    // 如果存在后繼節(jié)點(diǎn)，就喚醒
    private void unparkSuccessor(Node node) {
        // 獲得節(jié)點(diǎn)的狀態(tài)
        int ws = node.waitStatus;
        // 如果為負(fù)數(shù)，就執(zhí)行比較并設(shè)置方法設(shè)置狀態(tài)
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        // 喚醒后面的節(jié)點(diǎn)
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

    // 共享模式的釋放動(dòng)作，并且向后繼節(jié)點(diǎn)發(fā)出信號(hào)
    private void doReleaseShared() {
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }

    // 設(shè)置隊(duì)列的頭，并檢查后繼者能否在共享模式下等待，如果可以，就是否傳播設(shè)置為＞0或者propagate狀態(tài)
    private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // Record old head for check below
        setHead(node);

        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            if (s == null || s.isShared())
                doReleaseShared();
        }
    }

    // 取消正在進(jìn)行的嘗試
    private void cancelAcquire(Node node) {
        // 節(jié)點(diǎn)為null，直接返回
        if (node == null)
            return;

        node.thread = null;

        // 跳過(guò)已經(jīng)取消的前一個(gè)節(jié)點(diǎn)
        Node pred = node.prev;
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;

        Node predNext = pred.next;

        node.waitStatus = Node.CANCELLED;

        if (node == tail && compareAndSetTail(node, pred)) {
            compareAndSetNext(pred, predNext, null);
        } else {
            int ws;
            if (pred != head &&
                ((ws = pred.waitStatus) == Node.SIGNAL ||
                 (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
                pred.thread != null) {
                Node next = node.next;
                if (next != null && next.waitStatus <= 0)
                    compareAndSetNext(pred, predNext, next);
            } else {
                unparkSuccessor(node);
            }

            node.next = node; // help GC
        }
    }

    // 還有好多方法... 其實(shí)本質(zhì)就是基于 隊(duì)列的判斷和操作，AQS提供了獨(dú)占鎖和共享鎖的設(shè)計(jì)
    // 在AQS中，使用到了Unsafe類(lèi)，所以AQS其實(shí)就是基于CAS算法的，
    // AQS的一些方法就是直接調(diào)用 Unsafe 的方法 如下所示

    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long stateOffset;
    private static final long headOffset;
    private static final long tailOffset;
    private static final long waitStatusOffset;
    private static final long nextOffset;

    static {
        try {
            stateOffset = unsafe.objectFieldOffset
                (AbstractQueuedSynchronizer.class.getDeclaredField("state"));
            headOffset = unsafe.objectFieldOffset
                (AbstractQueuedSynchronizer.class.getDeclaredField("head"));
            tailOffset = unsafe.objectFieldOffset
                (AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
            waitStatusOffset = unsafe.objectFieldOffset
                (Node.class.getDeclaredField("waitStatus"));
            nextOffset = unsafe.objectFieldOffset
                (Node.class.getDeclaredField("next"));

        } catch (Exception ex) { throw new Error(ex); }
    }

    // 比較并設(shè)置頭
    private final boolean compareAndSetHead(Node update) {
        return unsafe.compareAndSwapObject(this, headOffset, null, update);
    }

    // 比較并設(shè)置尾
    private final boolean compareAndSetTail(Node expect, Node update) {
        return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
    }

    // 比較并設(shè)置狀態(tài)
    private static final boolean compareAndSetWaitStatus(Node node,
                                                         int expect,
                                                         int update) {
        return unsafe.compareAndSwapInt(node, waitStatusOffset,
                                        expect, update);
    }

    // 比較并設(shè)置下一個(gè)節(jié)點(diǎn)
    private static final boolean compareAndSetNext(Node node,
                                                   Node expect,
                                                   Node update) {
        return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
    }

    // 除此之外 AQS 還有一個(gè)實(shí)現(xiàn)了Condition的類(lèi) 如下
    public class ConditionObject implements Condition, java.io.Serializable {
        private static final long serialVersionUID = 1173984872572414699L;

        // 條件隊(duì)列的第一個(gè)節(jié)點(diǎn)
        private transient Node firstWaiter;

        // 條件隊(duì)列的最后一個(gè)節(jié)點(diǎn)
        private transient Node lastWaiter;

        public ConditionObject() { }

        // 在等待隊(duì)列中添加一個(gè)新的節(jié)點(diǎn)
        private Node addConditionWaiter() {
            // 獲取最后一個(gè)節(jié)點(diǎn)
            Node t = lastWaiter;
            // 如果最后一個(gè)節(jié)點(diǎn)被取消了，就清除它
            if (t != null && t.waitStatus != Node.CONDITION) {
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            Node node = new Node(Thread.currentThread(), Node.CONDITION);
            if (t == null)
                firstWaiter = node;
            else
                t.nextWaiter = node;
            lastWaiter = node;
              return node;
        }

        // 刪除并轉(zhuǎn)移節(jié)點(diǎn)直到它沒(méi)有取消或者不為null
        private void doSignal(Node first) {
            do {
                if ( (firstWaiter = first.nextWaiter) == null)
                    lastWaiter = null;
                first.nextWaiter = null;
            } while (!transferForSignal(first) &&
                     (first = firstWaiter) != null);
        }

        // 刪除所有的節(jié)點(diǎn)
        private void doSignalAll(Node first) {
            lastWaiter = firstWaiter = null;
            do {
                Node next = first.nextWaiter;
                first.nextWaiter = null;
                transferForSignal(first);
                first = next;
            } while (first != null);
        }

        // 取消節(jié)點(diǎn)的連接
        private void unlinkCancelledWaiters() {
            Node t = firstWaiter;
            Node trail = null;
            while (t != null) {
                Node next = t.nextWaiter;
                if (t.waitStatus != Node.CONDITION) {
                    t.nextWaiter = null;
                    if (trail == null)
                        firstWaiter = next;
                    else
                        trail.nextWaiter = next;
                    if (next == null)
                        lastWaiter = trail;
                }
                else
                    trail = t;
                t = next;
            }
        }

        // 將等待最長(zhǎng)的線程，喚醒
        public final void signal() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }

        // 喚醒所有的等待線程
        public final void signalAll() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignalAll(first);
        }

        // 實(shí)現(xiàn)不間斷的條件等待
        public final void awaitUninterruptibly() {
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            boolean interrupted = false;
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if (Thread.interrupted())
                    interrupted = true;
            }
            if (acquireQueued(node, savedState) || interrupted)
                selfInterrupt();
        }

        // 模式意味著在退出等待時(shí)重新中斷
        private static final int REINTERRUPT =  1;

        // 模式的含義是在退出等待時(shí)拋出InterruptedException異常
        private static final int THROW_IE    = -1;

        // 檢查中斷，如果在信號(hào)通知之前被中斷，則返回THROW_IE；
        // 如果在信號(hào)通知之后，則返回REINTERRUPT；如果未被中斷，則返回 0
        private int checkInterruptWhileWaiting(Node node) {
            return Thread.interrupted() ?
                (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
            0;
        }

        // 拋出InterruptedException，重新中斷當(dāng)前線程，
        // 或不執(zhí)行任何操作，具體取決于模式。
        private void reportInterruptAfterWait(int interruptMode)
            throws InterruptedException {
            if (interruptMode == THROW_IE)
                throw new InterruptedException();
            else if (interruptMode == REINTERRUPT)
                selfInterrupt();
        }

        // 實(shí)現(xiàn)不可中斷的條件等待
        public final void await() throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

        // 納秒級(jí)別的等待
        public final long awaitNanos(long nanosTimeout)
            throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            final long deadline = System.nanoTime() + nanosTimeout;
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                if (nanosTimeout <= 0L) {
                    transferAfterCancelledWait(node);
                    break;
                }
                if (nanosTimeout >= spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
                nanosTimeout = deadline - System.nanoTime();
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null)
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
            return deadline - System.nanoTime();
        }

        // 絕對(duì)定時(shí)等待
        public final boolean awaitUntil(Date deadline)
            throws InterruptedException {
            long abstime = deadline.getTime();
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            boolean timedout = false;
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                if (System.currentTimeMillis() > abstime) {
                    timedout = transferAfterCancelledWait(node);
                    break;
                }
                LockSupport.parkUntil(this, abstime);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null)
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
            return !timedout;
        }

        // 超時(shí)等待
        public final boolean await(long time, TimeUnit unit)
            throws InterruptedException {
            long nanosTimeout = unit.toNanos(time);
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            final long deadline = System.nanoTime() + nanosTimeout;
            boolean timedout = false;
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                if (nanosTimeout <= 0L) {
                    timedout = transferAfterCancelledWait(node);
                    break;
                }
                if (nanosTimeout >= spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
                nanosTimeout = deadline - System.nanoTime();
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null)
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
            return !timedout;
        }

        // 判斷是不是獨(dú)占的
        final boolean isOwnedBy(AbstractQueuedSynchronizer sync) {
            return sync == AbstractQueuedSynchronizer.this;
        }

        // 返回是否有正在等待的
        protected final boolean hasWaiters() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
                if (w.waitStatus == Node.CONDITION)
                    return true;
            }
            return false;
        }

        // 獲得等待隊(duì)列的長(zhǎng)度
        protected final int getWaitQueueLength() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            int n = 0;
            for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
                if (w.waitStatus == Node.CONDITION)
                    ++n;
            }
            return n;
        }

        // 獲取所有正在等待的線程集合
        protected final Collection<Thread> getWaitingThreads() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            ArrayList<Thread> list = new ArrayList<Thread>();
            for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
                if (w.waitStatus == Node.CONDITION) {
                    Thread t = w.thread;
                    if (t != null)
                        list.add(t);
                }
            }
            return list;
        }
    }
}

public class Demo {
    volatile static int count = 0;

    public static void request() throws Exception {
        TimeUnit.MILLISECONDS.sleep(5);
        // 表示期望值
        int expectedCount;
        while (!compareAndSwap(expectedCount = getCount(), expectedCount + 1)) {
        }
    }

    public static synchronized boolean compareAndSwap(int expectedCount, int newValue) {
        if (expectedCount == getCount()) {
            count = newValue;
            return true;
        }
        return false;
    }

    public static int getCount() {
        return count;
    }

    public static void main(String[] args) throws Exception {
        long start = System.currentTimeMillis();
        int threadSize = 100;
        CountDownLatch countDownLatch = new CountDownLatch(threadSize);
        for (int i = 0; i < threadSize; i++) {
            new Thread(() -> {
                try {
                    for (int j = 0; j < 10; j++) {
                        request();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await();
        long end = System.currentTimeMillis();
        System.out.println("count :" + count + " 耗時(shí)：" + (end - start));
    }
}

public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

public class CasAbaDemo {
    public static AtomicInteger a = new AtomicInteger(1);

    public static void main(String[] args) {
        Thread main = new Thread(() -> {
            System.out.println("CasAbaDemo.main " + Thread.currentThread().getName() + ",初始值 " + a.get());
            try {
                int executedNum = a.get();
                int newNum = executedNum + 1;
                TimeUnit.SECONDS.sleep(3);
                boolean isCasSuccess = a.compareAndSet(executedNum, newNum);
                System.out.println(Thread.currentThread().getName() + ",CAS 操作:" + isCasSuccess);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "主線程");

        Thread thread = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                a.incrementAndGet();
                System.out.println(Thread.currentThread().getName() + ",incrementAndGet,之后" + a.get());
                a.decrementAndGet();
                System.out.println(Thread.currentThread().getName() + ",decrementAndGet,之后" + a.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "干擾線程");

        main.start();
        thread.start();
    }
}

public class AtomicStampedReference<V> {

    private static class Pair<T> {
        // 數(shù)據(jù)引用
        final T reference;
        // 版本號(hào)
        final int stamp;
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }

    private volatile Pair<V> pair;

    /**
     * 期望引用
     * @param expectedReference the expected value of the reference
     * 新值引用
     * @param newReference the new value for the reference
     * 期望引用的版本號(hào)
     * @param expectedStamp the expected value of the stamp
     * 新值的版本號(hào)
     * @param newStamp the new value for the stamp
     * @return {@code true} if successful
     */
    public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        return
            // 期望引用與當(dāng)前引用一致
            expectedReference == current.reference &&
            // 期望版本與當(dāng)前版本一致
            expectedStamp == current.stamp &&
            // 數(shù)據(jù)一致
            ((newReference == current.reference &&
              newStamp == current.stamp) 
             ||
             // 數(shù)據(jù)不一致
             casPair(current, Pair.of(newReference, newStamp)));
    }   
}

public class CasAbaDemo02 {
    public static AtomicStampedReference<Integer> a = new AtomicStampedReference(new Integer(1), 1);

    public static void main(String[] args) {
        Thread main = new Thread(() -> {
            System.out.println("CasAbaDemo.main " + Thread.currentThread().getName() + ",初始值 " + a.getReference());
            try {
                Integer executedReference = a.getReference();
                Integer newReference = executedReference + 1;
                Integer expectStamp = a.getStamp();
                Integer newStamp = expectStamp + 1;
                TimeUnit.SECONDS.sleep(3);
                boolean isCasSuccess = a.compareAndSet(executedReference, newReference, expectStamp, newStamp);
                System.out.println(Thread.currentThread().getName() + ",CAS 操作:" + isCasSuccess);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "主線程");

        Thread thread = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                a.compareAndSet(a.getReference(), a.getReference() + 1, a.getStamp(), a.getStamp() + 1);
                System.out.println(Thread.currentThread().getName() + ",incrementAndGet,之后" + a.getReference());
                a.compareAndSet(a.getReference(), a.getReference() - 1, a.getStamp(), a.getStamp() - 1);
                System.out.println(Thread.currentThread().getName() + ",decrementAndGet,之后" + a.getReference());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "干擾線程");

        main.start();
        thread.start();
    }
}