前言：上一節(jié)實(shí)現(xiàn)了一個(gè)自定義鎖透且，并且驗(yàn)證了其功能似嗤，這節(jié)將從源碼出發(fā)，解析J.U.C的源碼，并引出抽象隊(duì)列同步器（AQS）账蓉。

1 JDK的ReentrantLock

1.1 ReentrantLock

上節(jié)我們自己實(shí)現(xiàn)了tryLock、lock工三、unlock三個(gè)方法架谎，我們先從這三個(gè)方法入手，看JDK的實(shí)現(xiàn)跟我們自己的實(shí)現(xiàn)有什么異同。

先給出類圖：

從類圖可以看出君纫，ReentrantLock有三個(gè)內(nèi)部類驯遇，而Sync是AbstractQueuedSynchronizer的子類，而Sync有公平和非公平的兩個(gè)子類蓄髓。

1.1.1 ReentrantLock#tryLock

我們先捋一捋tryLock應(yīng)該會(huì)有什么樣的實(shí)現(xiàn)
1）ReentrantLock應(yīng)該有屬性來(lái)確定鎖是被哪個(gè)線程所占用
2）tryLock即是多個(gè)線程會(huì)同時(shí)去修改1）中所提及的屬性叉庐，修改成功，則說(shuō)明該線程占有該鎖会喝。

1.1.1.1 找到確定線程占用的屬性

ReentrantLock只有一個(gè)field：Sync-> AbstractQueuedSynchronizer（以下簡(jiǎn)稱為AQS）

點(diǎn)開到AbstractOwnableSynchronizer發(fā)現(xiàn)了這個(gè)屬性

/**
 * The current owner of exclusive mode synchronization.
 */
private transient Thread exclusiveOwnerThread;

1.1.1.2 解析tryLock方法

ReentrantLock#tryLock

public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}

Sync#nonfairTryAcquire

AbstractQueuedSynchronizer# compareAndSetState

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

AbstractOwnableSynchronizer# setExclusiveOwnerThread

protected final void setExclusiveOwnerThread(Thread thread) {
    exclusiveOwnerThread = thread;
}

說(shuō)明：從nonfairTryAcquire 的if塊看來(lái)陡叠，首先是多個(gè)線程來(lái)設(shè)置AQS的state屬性，設(shè)置成功則說(shuō)明擁有該鎖肢执，else塊用于在當(dāng)前線程已經(jīng)擁有該鎖時(shí)枉阵，再繼續(xù)來(lái)獲取該鎖，重入時(shí)增加鎖的次數(shù)预茄。（注：Exclusive此處應(yīng)該翻譯為互斥的兴溜、排他的）

1.1.2 ReentrantLock#lock

ReentrantLock#lock

public void lock() {
    sync.lock();
}

Sync#lock

abstract void lock();

實(shí)現(xiàn)類有公平和非公平

公平和非公平的區(qū)別在于，搶鎖的時(shí)候耻陕，假設(shè)當(dāng)前線程一占有著鎖拙徽，線程二和線程三之前已經(jīng)搶過(guò)了，沒(méi)搶到诗宣，然后線程一此時(shí)將鎖釋放掉斋攀，會(huì)喚醒等待池（鎖池）中的線程二、三搶鎖梧田，但是此時(shí)剛好線程四也來(lái)?yè)屃舜景€程四之前是不在等待池里的，這時(shí)候就有可能被后來(lái)的線程四搶到了鎖裁眯，所以這種情況就是非公平的鹉梨。
而公平和非公平的實(shí)現(xiàn)區(qū)別就在于，公平的會(huì)先去判斷當(dāng)前搶鎖的線程是否在等待池中穿稳，是的話才讓它去搶鎖存皂。

NonfairSync# lock

compareAndSetState，當(dāng)前鎖出現(xiàn)多線程爭(zhēng)搶的情況下逢艘，哪個(gè)線程設(shè)置state成功旦袋，鎖就歸哪個(gè)線程所有，compareAndSetState底層是使用unsafe硬件同步原語(yǔ)來(lái)保證只有一個(gè)線程能成功它改，這樣來(lái)保證原子性的疤孕，而對(duì)于設(shè)置不成功state屬性的線程（即搶不到鎖的線程，執(zhí)行acquire(1)）
這里還要說(shuō)明一下compareAndSetState還有一種情況會(huì)失敗央拖，就是當(dāng)前線程已經(jīng)搶到該鎖了祭阀，然后又需要再鎖一次（即重入）

AbstractQueuedSynchronizer# acquire

public final void acquire(int arg) {
    if (!tryAcquire(arg) && // 嘗試獲取鎖鹉戚，獲取不到則添加當(dāng)前線程到等待池
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))//Node.EXEXCLUSIVE是null值，若mode為互斥類型的专控，說(shuō)明鎖的下個(gè)等待者為空
        selfInterrupt();
}

tryAcquire(arg)：若當(dāng)前線程重入成功需要記錄讓state++抹凳，說(shuō)明加鎖次數(shù)+1

AbstractQueuedSynchronizer# addWaiter

private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);//有獨(dú)占模式和共享模式 mode為null意味著獨(dú)占模式
    // 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)) {//設(shè)置tail為當(dāng)前節(jié)點(diǎn)
            pred.next = node;
            return node;
        }
    }
    enq(node);//將設(shè)置成功的線程的節(jié)點(diǎn)入隊(duì) enq->insert into queue
    return node;
}

從addWaiter可以看到，AbstractQueuedSynchronizer是使用鏈表來(lái)作為鎖池伦腐，存儲(chǔ)等待該鎖的所有線程赢底，并且把每個(gè)新加入爭(zhēng)搶的線程保存在鏈表的尾部。
AbstractQueuedSynchronizer# acquireQueued

藍(lán)色的部分說(shuō)明沒(méi)有搶到鎖的線程柏蘑，最后都會(huì)進(jìn)入Park的狀態(tài)幸冻。

AbstractQueuedSynchronizer#release流程

AQS#acquire

1.1.3 ReentrantLock#unlock

ReentrantLock#unlock

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

AbstractQueuedSynchronizer# release

AbstractQueuedSynchronizer# tryRelease

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

查看tryRelease的實(shí)現(xiàn)

ReentrantLock #Sync# tryRelease

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;
}

tryRelease方法比較簡(jiǎn)單，就是判斷重入的次數(shù)是否為0了辩越，若為0則將占有鎖的屬性設(shè)置為null。
回到AbstractQueuedSynchronizer# release信粮，查看unparkSuccessor
AbstractQueuedSynchronizer# unparkSuccessor（從名字上看是unpark繼任者）

private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    /*
     * Thread to unpark is held in successor, which is normally
     * just the next node.  But if cancelled or apparently null,
     * traverse backwards from tail to find the actual
     * non-cancelled successor.
     */
    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);
}

此處主要就是從隊(duì)列中拿出符合狀態(tài)的繼任者黔攒，繼續(xù)將該線程unpark。

AbstractQueuedSynchronizer#release流程

AQS#release

從tryLock强缘、lock督惰、unlock三個(gè)方法可以看出，AQS作為一個(gè)抽象類旅掂，主要是提供一個(gè)模板方法赏胚，tryLock、tryRelease都讓子類去實(shí)現(xiàn)商虐，它不關(guān)心你是要怎么鎖的觉阅，它只關(guān)心你獲取鎖后怎樣存儲(chǔ)這些爭(zhēng)搶鎖的線程以及將它們阻塞起來(lái)，它還關(guān)心釋放鎖之后找到下一個(gè)繼任者秘车，并且將下個(gè)繼任者unpark置為非阻塞典勇。
方法對(duì)照：
Lock子類的lock方法<-->AQS的acquire
Lock子類的unlock方法<-->AQS的release

2 JDK的AbstractQueuedSynchronizer

2.1 分析AbstractQueuedSynchronizer繼承結(jié)構(gòu)與屬性

1）鎖池
前面說(shuō)過(guò)抽象隊(duì)列同步器提供的模板方法，將管理鎖池叮趴、阻塞線程割笙、釋放線程的邏輯都放到了AQS中，AQS中有兩個(gè)內(nèi)部類眯亦，一個(gè)是Node伤溉，前面相關(guān)的源碼已經(jīng)有說(shuō)明了，AQS是通過(guò)鏈表來(lái)維護(hù)這個(gè)鎖池的妻率。
2）鎖持有者
AbstractOwnableSynchronizer中的exclusiveOwnerThread乱顾，標(biāo)志著當(dāng)前互斥鎖由哪個(gè)線程持有
3）記錄重入次數(shù)
AbstractQueuedSynchronizer中的state屬性記錄重入的次數(shù)

Node節(jié)點(diǎn)

Node中有兩個(gè)屬性被用來(lái)標(biāo)志當(dāng)前的鎖是共享鎖還是獨(dú)占鎖，SHAREED標(biāo)志當(dāng)前線程搶的鎖是共享鎖宫静，而EXCLUSIVE標(biāo)志的是當(dāng)前線程搶的鎖是獨(dú)占鎖糯耍。

2.2 AbstractQueuedSynchronizer提供的功能

AQS實(shí)際上是抽象出鎖的實(shí)現(xiàn)扔字，提供了對(duì)資源占用、釋放温技，線程的等待革为、喚醒等等接口和具體實(shí)現(xiàn)。
可以用在各種需要控制資源爭(zhēng)用的場(chǎng)景中舵鳞。（ReentrantLock/CountDownLatch/Semphore）

acquire震檩、acquireShared：定義了資源爭(zhēng)用的邏輯，如果沒(méi)拿到蜓堕，則等待抛虏。
tryAcquire、tryAcquireShared：實(shí)際執(zhí)行占用資源的操作套才，如何判定由具體的AQS使用者去實(shí)現(xiàn)迂猴。
release、releaseShared：定義釋放資源的邏輯背伴，釋放之后沸毁，通知后續(xù)節(jié)點(diǎn)進(jìn)行爭(zhēng)搶。
tryRelease傻寂、tryReleaseShared：實(shí)際執(zhí)行資源釋放的操作息尺，由具體的AQS使用者去實(shí)現(xiàn)。

3 使用自定義的AQS實(shí)現(xiàn)讀寫鎖

state除了記錄重入次數(shù)之外疾掰，在讀寫鎖中還會(huì)記錄當(dāng)前有多少個(gè)讀線程持有該鎖搂誉。當(dāng)有線程請(qǐng)求讀鎖時(shí)，state++静檬。

AQS中tryAcquire炭懊、tryRelease、tryAcquireShared拂檩、tryReleaseShared這四個(gè)方法是抽象方法凛虽，由子類去實(shí)現(xiàn)。
在這個(gè)自定義的AQS中實(shí)現(xiàn)了acquire广恢、release凯旋、acquireShared、releaseShared這四個(gè)方法

1）acquire
作用：獲取獨(dú)占鎖

userDefinedAQS#acquire

2）release
作用：釋放獨(dú)占鎖
邏輯：（注意此處的拿出是peek钉迷，要從等待池中移除得獲取到鎖才能移除）

userDefinedAQS#release

3）acquireShared
作用：獲取共享鎖

userDefinedAQS#acquireShare

4）releaseSharead
作用：釋放共享鎖
邏輯：（注意此處的拿出是peek至非，要從等待池中移除得獲取到鎖才能移除）

userDefinedAQS#releaseShare

在讀寫鎖中，
tryAcquire：判斷state是否為0糠聪，為0則說(shuō)明沒(méi)有線程獲取讀鎖荒椭，繼續(xù)CAS操作AQS中的owner屬性（設(shè)置為當(dāng)前線程），操作成功即線程搶到了鎖（由CAS機(jī)制保證同一時(shí)刻只有一個(gè)線程能成功設(shè)置owner屬性）
tryRelease：CAS操作AQS中的owner屬性（設(shè)置為null）舰蟆，操作成功即表示釋放鎖成功
tryAcquireShared：判斷是否owner屬性有值（有值說(shuō)明趣惠，已經(jīng)有線程獲取了寫鎖了）狸棍，若是當(dāng)前線程獲取了寫鎖，則能繼續(xù)獲取讀鎖味悄，否則獲取讀鎖失敗草戈，若owner屬性為null，則直接CAS state屬性+1侍瑟，成功則獲取到了讀鎖唐片。
tryReleaseShared：直接CAS state屬性-1，成功則釋放了讀鎖涨颜。

3.1 自定義AQS代碼實(shí)現(xiàn)

package szu.vander.aqs.demo;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;

/**
 * @author : Vander
 * @date :   2019/12/9
 * @description : 自定義抽象隊(duì)列同步器
 */
public abstract class UserDefinedAQS {
    // 同步資源狀態(tài)
    protected volatile AtomicInteger state = new AtomicInteger(0);
    // 當(dāng)前鎖的擁有者
    protected volatile AtomicReference<Thread> owner = new AtomicReference<>();
    // 線程安全的隊(duì)列
    public volatile LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();

    /**
     * 獲取獨(dú)占鎖
     */
    public void acquire() {
        // 塞到等待鎖的集合中
        waiters.offer(Thread.currentThread());
        while (!tryAcquire()) {// 用while是因?yàn)楸粏拘蚜丝赡苓€是搶不到要繼續(xù)掛起
            // 掛起這個(gè)線程
            LockSupport.park();
        }
        // 后續(xù)费韭，等待其他線程釋放鎖，收到通知之后繼續(xù)循環(huán)
        waiters.remove(Thread.currentThread());
    }

    /**
     * 釋放鎖
     */
    public void release() {
        // cas 修改 owner 擁有者
        if (tryRelease()) {
            Thread waiter = waiters.peek();// 拿到隊(duì)頭的線程庭瑰，而不是出隊(duì)
            LockSupport.unpark(waiter); // 喚醒線程星持，繼續(xù)搶鎖
        }
    }

    /**
     * 嘗試獲取獨(dú)占資源
     * @return
     */
    public abstract boolean tryAcquire();

    /**
     * 嘗試釋放獨(dú)占資源
     * @return
     */
    public abstract boolean tryRelease();

    /**
     * 共享資源獲取
     */
    public void acquireShared() {
        // 塞到等待鎖的集合中
        waiters.offer(Thread.currentThread());
        while (tryAcquireShared() < 0) {// 返回剩余資源的個(gè)數(shù)
            // 掛起這個(gè)線程
            LockSupport.park();
        }
        // 后續(xù)，等待其他線程釋放鎖弹灭，收到通知之后繼續(xù)循環(huán)
        waiters.remove(Thread.currentThread());
    }

    /**
     * 共享資源的釋放
     */
    public void releaseShared() {
        // cas 修改 owner 擁有者
        if (tryReleaseShared()) {
            Thread waiter = waiters.peek();// 拿到隊(duì)頭的線程
            LockSupport.unpark(waiter); // 喚醒線程,繼續(xù)搶鎖
        }
    }

    /**
     * 嘗試獲取共享資源
     * @return
     */
    public abstract int tryAcquireShared();

    /**
     * 嘗試釋放共享資源
     * @return
     */
    public abstract boolean tryReleaseShared();

}

3.2 自定義ReadWriteLock代碼實(shí)現(xiàn)

package szu.vander.aqs.demo;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;

/**
 * @author : Vander
 * @date :   2019/12/15
 * @description :
 */
public class UserDefinedReadWriteLock implements ReadWriteLock {

    private final UserDefinedReadWriteLock.ReadLock readerLock;

    private final UserDefinedReadWriteLock.WriteLock writerLock;

    private final ReadWriteSync sync;

    public UserDefinedReadWriteLock() {
        sync = new ReadWriteSync();
        readerLock = new UserDefinedReadWriteLock.ReadLock(this);
        writerLock = new UserDefinedReadWriteLock.WriteLock(this);
    }

    static class ReadWriteSync extends UserDefinedAQS {

        /**
         * 獲取共享資源督暂，即state++，嘗試獲取讀鎖的時(shí)候調(diào)用此方法鲤屡，本質(zhì)是設(shè)置state损痰，讓state+1
         * @return
         */
        @Override
        public int tryAcquireShared() {
            // 如果當(dāng)前有線程占用了寫鎖福侈，則不允許再加鎖酒来，除非是同一個(gè)線程
            if (owner.get() != null && !owner.get().equals(Thread.currentThread())) {
                return -1;
            }
            return state.incrementAndGet();
        }

        /**
         * 嘗試獲取讀鎖
         * @return
         */
        public boolean tryReadLock() {
            if(tryAcquireShared() > 0) {
                return true;
            }
            return false;
        }

        /**
         * 釋放共享鎖，即state--
         * @return
         */
        @Override
        public boolean tryReleaseShared() {
            return state.decrementAndGet() >= 0;
        }

        /**
         * 獲取獨(dú)占鎖肪凛，嘗試獲取寫鎖時(shí)調(diào)用堰汉，本質(zhì)是設(shè)置owner為當(dāng)前線程
         * @return
         */
        @Override
        public boolean tryAcquire() {
            // 有讀的時(shí)候，不能寫
            if (state.get() != 0) {
                return false;
            } else {
                return owner.compareAndSet(null, Thread.currentThread());
            }
        }

        /**
         * 嘗試獲取寫鎖
         * @return
         */
        public boolean tryWriteLock() {
            return tryAcquire();
        }

        /**
         * 釋放獨(dú)占鎖
         * @return
         */
        @Override
        public boolean tryRelease() {
            return owner.compareAndSet(Thread.currentThread(), null);
        }

    }

    @Override
    public Lock readLock() {
        return this.readerLock;
    }

    @Override
    public Lock writeLock() {
        return this.writerLock;
    }

    public static class ReadLock implements Lock{

        private ReadWriteSync readWriteSync;

        protected ReadLock(UserDefinedReadWriteLock readWriteLock) {
            readWriteSync = readWriteLock.sync;
        }

        @Override
        public boolean tryLock() {
            return readWriteSync.tryReadLock();
        }

        @Override
        public void lock() {
            readWriteSync.acquireShared();
        }

        @Override
        public void unlock() {
            readWriteSync.releaseShared();
        }

        @Override
        public void lockInterruptibly() throws InterruptedException {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
            throw new UnsupportedOperationException();
        }

        @Override
        public Condition newCondition() {
            throw new UnsupportedOperationException();
        }
    }

    public static class WriteLock implements Lock{

        private ReadWriteSync readWriteSync;

        protected WriteLock(UserDefinedReadWriteLock readWriteLock) {
            readWriteSync = readWriteLock.sync;
        }

        @Override
        public boolean tryLock() {
            return readWriteSync.tryWriteLock();
        }

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

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

        @Override
        public void lockInterruptibly() throws InterruptedException {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
            throw new UnsupportedOperationException();
        }

        @Override
        public Condition newCondition() {
            throw new UnsupportedOperationException();
        }
    }

}

測(cè)試類：

package szu.vander.test.aqs;

import org.junit.Test;
import szu.vander.aqs.demo.UserDefinedReadWriteLock;
import szu.vander.log.Logger;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @author : Vander
 * @date :   2019/12/15
 * @description :
 */
public class UserDefinedReadWriteLockTest {

    private UserDefinedReadWriteLock readWriteLock = new UserDefinedReadWriteLock();

    private Map<String, String> container = new HashMap<>();

    private Logger log = new Logger();

    @Test
    public void test() throws InterruptedException {
        Thread writeThread = new Thread(new Runnable() {
            @Override
            public void run() {
                readWriteLock.writeLock().lock();
                log.info("獲取到寫鎖");
                container.put("key1", "value1");
                readWriteLock.writeLock().unlock();
                log.info("釋放寫鎖");
            }
        });

        Thread readThread1 = new Thread(new RunnableImpl());
        Thread readThread2 = new Thread(new RunnableImpl());
        Thread readThread3 = new Thread(new RunnableImpl());

        readThread1.start();
        TimeUnit.MILLISECONDS.sleep(200);
        readThread2.start();
        TimeUnit.MILLISECONDS.sleep(200);
        writeThread.start();
        TimeUnit.MILLISECONDS.sleep(200);
        // 等寫鎖獲取到了之后伟墙，寫完數(shù)據(jù)后再次獲取讀鎖
        TimeUnit.SECONDS.sleep(5);
        readThread3.start();
        // 讓程序運(yùn)行完
        TimeUnit.SECONDS.sleep(10);
    }

    private class RunnableImpl implements Runnable {
        @Override
        public void run() {
            readWriteLock.readLock().lock();
            log.info("獲取到讀鎖");
            log.info("讀取Container中的內(nèi)容翘鸭，key1=" + container.get("key1"));
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            readWriteLock.readLock().unlock();
            log.info("釋放讀鎖");
        }
    }

}

運(yùn)行結(jié)果：

雖然寫鎖線程很早就啟動(dòng)了，但是由于讀鎖沒(méi)有釋放戳葵，所以寫鎖一直沒(méi)有獲取到直到讀鎖釋放就乓，寫鎖獲取到了之后，其它線程就沒(méi)辦法獲取讀鎖了拱烁，直到寫鎖的線程將寫鎖釋放生蚁。