private volatile int state;//共享變量，使用volatile修飾保證線程可見性

package juc;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
public class Mutex implements java.io.Serializable {
    //靜態(tài)內(nèi)部類，繼承AQS
    private static class Sync extends AbstractQueuedSynchronizer {
        //是否處于占用狀態(tài)
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }
        //當(dāng)狀態(tài)為0的時(shí)候獲取鎖，CAS操作成功，則state狀態(tài)為1，
        public boolean tryAcquire(int acquires) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
        //釋放鎖，將同步狀態(tài)置為0
        protected boolean tryRelease(int releases) {
            if (getState() == 0) throw new IllegalMonitorStateException();
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
    }
        //同步對(duì)象完成一系列復(fù)雜的操作，我們僅需指向它即可
        private final Sync sync = new Sync();
        //加鎖操作，代理到acquire（模板方法）上就行，acquire會(huì)調(diào)用我們重寫的tryAcquire方法
        public void lock() {
            sync.acquire(1);
        }
        public boolean tryLock() {
            return sync.tryAcquire(1);
        }
        //釋放鎖，代理到release（模板方法）上就行，release會(huì)調(diào)用我們重寫的tryRelease方法。
        public void unlock() {
            sync.release(1);
        }
        public boolean isLocked() {
            return sync.isHeldExclusively();
        }
}

package juc;

import java.util.concurrent.CyclicBarrier;

public class TestMutex {
    private static CyclicBarrier barrier = new CyclicBarrier(31);
    private static int a = 0;
    private static  Mutex mutex = new Mutex();

    public static void main(String []args) throws Exception {
        //說明:我們啟用30個(gè)線程，每個(gè)線程對(duì)i自加10000次，同步正常的話，最終結(jié)果應(yīng)為300000；
        //未加鎖前
        for(int i=0;i<30;i++){
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i=0;i<10000;i++){
                        increment1();//沒有同步措施的a++；
                    }
                    try {
                        barrier.await();//等30個(gè)線程累加完畢
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        }
        barrier.await();
        System.out.println("加鎖前，a="+a);
        //加鎖后
        barrier.reset();//重置CyclicBarrier
        a=0;
        for(int i=0;i<30;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i=0;i<10000;i++){
                        increment2();//a++采用Mutex進(jìn)行同步處理
                    }
                    try {
                        barrier.await();//等30個(gè)線程累加完畢
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
        barrier.await();
        System.out.println("加鎖后，a="+a);
    }
    /**
    * 沒有同步措施的a++
    * @return
    */
    public static void increment1(){
        a++;
    }
    /**
    * 使用自定義的Mutex進(jìn)行同步處理的a++
    */
    public static void increment2(){
        mutex.lock();
        a++;
        mutex.unlock();
    }
}

static final class Node {
        /** waitStatus值，表示線程已被取消（等待超時(shí)或者被中斷）*/
        static final int CANCELLED =  1;
        /** waitStatus值，表示后繼線程需要被喚醒（unpaking）*/
        static final int SIGNAL    = -1;
        /**waitStatus值，表示結(jié)點(diǎn)線程等待在condition上，當(dāng)被signal后，會(huì)從等待隊(duì)列轉(zhuǎn)移到同步到隊(duì)列中 */
        /** waitStatus value to indicate thread is waiting on condition */
        static final int CONDITION = -2;
       /** waitStatus值，表示下一次共享式同步狀態(tài)會(huì)被無條件地傳播下去
        static final int PROPAGATE = -3;
        /** 等待狀態(tài)，初始為0 */
        volatile int waitStatus;
        /**當(dāng)前結(jié)點(diǎn)的前驅(qū)結(jié)點(diǎn) */
        volatile Node prev;
        /** 當(dāng)前結(jié)點(diǎn)的后繼結(jié)點(diǎn) */
        volatile Node next;
        /** 與當(dāng)前結(jié)點(diǎn)關(guān)聯(lián)的排隊(duì)中的線程 */
        volatile Thread thread;
        /** ...... */
    }

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

private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);//構(gòu)造結(jié)點(diǎn)
    //指向尾結(jié)點(diǎn)tail
    Node pred = tail;
    //如果尾結(jié)點(diǎn)不為空，CAS快速嘗試在尾部添加，若CAS設(shè)置成功，返回；否則，eng。
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { //如果隊(duì)列為空，創(chuàng)建結(jié)點(diǎn)，同時(shí)被head和tail引用
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {//cas設(shè)置尾結(jié)點(diǎn)，不成功就一直重試
                t.next = node;
                return t;
            }
        }
    }
}

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {//死循環(huán)
            final Node p = node.predecessor();//找到當(dāng)前結(jié)點(diǎn)的前驅(qū)結(jié)點(diǎn)
            if (p == head && tryAcquire(arg)) {//如果前驅(qū)結(jié)點(diǎn)是頭結(jié)點(diǎn)，才tryAcquire，其他結(jié)點(diǎn)是沒有機(jī)會(huì)tryAcquire的。
                setHead(node);//獲取同步狀態(tài)成功，將當(dāng)前結(jié)點(diǎn)設(shè)置為頭結(jié)點(diǎn)。
                p.next = null; // 方便GC
                failed = false;
                return interrupted;
            }
            // 如果沒有獲取到同步狀態(tài)，通過shouldParkAfterFailedAcquire判斷是否應(yīng)該阻塞，parkAndCheckInterrupt用來阻塞線程
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //獲取前驅(qū)結(jié)點(diǎn)的wait值 
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)//若前驅(qū)結(jié)點(diǎn)的狀態(tài)是SIGNAL，意味著當(dāng)前結(jié)點(diǎn)可以被安全地park
        return true;
    if (ws > 0) {
    // ws>0，只有CANCEL狀態(tài)ws才大于0。若前驅(qū)結(jié)點(diǎn)處于CANCEL狀態(tài)，也就是此結(jié)點(diǎn)線程已經(jīng)無效，從后往前遍歷，找到一個(gè)非CANCEL狀態(tài)的結(jié)點(diǎn)，將自己設(shè)置為它的后繼結(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狀態(tài)
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);//使用LockSupport使線程進(jìn)入阻塞狀態(tài)
    return Thread.interrupted();// 線程是否被中斷過
}

public final boolean release(int arg) {
    if (tryRelease(arg)) {//調(diào)用使用者重寫的tryRelease方法，若成功，喚醒其后繼結(jié)點(diǎn)，失敗則返回false
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);//喚醒后繼結(jié)點(diǎn)
        return true;
    }
    return false;
}

private void unparkSuccessor(Node node) {
    //獲取wait狀態(tài)
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);// 將等待狀態(tài)waitStatus設(shè)置為初始值0
    Node s = node.next;//后繼結(jié)點(diǎn)
    if (s == null || s.waitStatus > 0) {//若后繼結(jié)點(diǎn)為空，或狀態(tài)為CANCEL（已失效），則從后尾部往前遍歷找到一個(gè)處于正常阻塞狀態(tài)的結(jié)點(diǎn)　　　　　進(jìn)行喚醒
        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);//使用LockSupprot喚醒結(jié)點(diǎn)對(duì)應(yīng)的線程
}

protected int tryAcquireShared(int arg) {
    throw new UnsupportedOperationException();
}

public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)//返回值小于0，獲取同步狀態(tài)失敗，排隊(duì)去；獲取同步狀態(tài)成功，直接返回去干自己的事兒。
        doAcquireShared(arg);
}

private void doAcquireShared(int arg) {
    final Node node = addWaiter(Node.SHARED);//構(gòu)造一個(gè)共享結(jié)點(diǎn)，添加到同步隊(duì)列尾部。若隊(duì)列初始為空，先添加一個(gè)無意義的傀儡結(jié)點(diǎn)，再將新節(jié)點(diǎn)添加到隊(duì)列尾部。
    boolean failed = true;//是否獲取成功
    try {
        boolean interrupted = false;//線程parking過程中是否被中斷過
        for (;;) {//死循環(huán)
            final Node p = node.predecessor();//找到前驅(qū)結(jié)點(diǎn)
            if (p == head) {//頭結(jié)點(diǎn)持有同步狀態(tài)，只有前驅(qū)是頭結(jié)點(diǎn)，才有機(jī)會(huì)嘗試獲取同步狀態(tài)
                int r = tryAcquireShared(arg);//嘗試獲取同步裝填
                if (r >= 0) {//r>=0,獲取成功
                    setHeadAndPropagate(node, r);//獲取成功就將當(dāng)前結(jié)點(diǎn)設(shè)置為頭結(jié)點(diǎn)，若還有可用資源，傳播下去，也就是繼續(xù)喚醒后繼結(jié)點(diǎn)
                    p.next = null; // 方便GC
                    if (interrupted)
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) &&//是否能安心進(jìn)入parking狀態(tài)
                parkAndCheckInterrupt())//阻塞線程
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

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) {
        Node s = node.next;
        if (s == null || s.isShared())
            doReleaseShared();
    }
}

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();//釋放同步狀態(tài)
        return true;
    }
    return false;
}

private void doReleaseShared() {
    for (;;) {//死循環(huán)，共享模式，持有同步狀態(tài)的線程可能有多個(gè)，采用循環(huán)CAS保證線程安全
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;          
                unparkSuccessor(h);//喚醒后繼結(jié)點(diǎn)
            }
            else if (ws == 0 &&
                        !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                
        }
        if (h == head)              
            break;
    }
}