public long readLock() {
    long s = state, next;  // bypass acquireRead on common uncontended case
    //同步隊列為空，讀鎖計數(shù)值未超過最大值（無寫鎖），CAS獲取鎖成功，則直接返回郵戳值；
    //否則acquireRead獲取讀鎖
    return ((whead == wtail && (s & ABITS) < RFULL &&
             U.compareAndSwapLong(this, STATE, s, next = s + RUNIT)) ?
            next : acquireRead(false, 0L));
}

private long acquireRead(boolean interruptible, long deadline) {
    WNode node = null, p;
    for (int spins = -1;;) {
        WNode h;
        //如果同步隊列頭節(jié)點等于尾節(jié)點，說明隊列中沒有節(jié)點或者只有一個節(jié)點
        //則自旋一段時間，等待頭結(jié)點釋放鎖后獲取鎖
        if ((h = whead) == (p = wtail)) {
            for (long m, s, ns;;) {
                //（state & ABITS）小于RFULL，表示無寫鎖，則直接CAS獲取讀鎖；
                //否則若（state & ABITS）小于WBIT表示無寫鎖但讀鎖計數(shù)已溢出，
                //則CAS更新讀鎖計數(shù)獲取讀鎖
                if ((m = (s = state) & ABITS) < RFULL ?
                    U.compareAndSwapLong(this, STATE, s, ns = s + RUNIT) :
                    (m < WBIT && (ns = tryIncReaderOverflow(s)) != 0L))
                    return ns;
                //（state & ABITS）大于WBIT，表示寫鎖已經(jīng)被占，則自旋    
                else if (m >= WBIT) {
                    //隨機(jī)減自旋次數(shù)
                    if (spins > 0) {
                        if (LockSupport.nextSecondarySeed() >= 0)
                            --spins;
                    }
                    else {
                        //自旋完還沒獲取到讀鎖？
                        if (spins == 0) {
                            WNode nh = whead, np = wtail;
                            //判斷穩(wěn)定性（有沒有被修改），跳出循環(huán)
                            if ((nh == h && np == p) || (h = nh) != (p = np))
                                break;
                        }
                        //初始化spins
                        spins = SPINS;
                    }
                }
            }
        }
        //自旋獲取失敗，則進(jìn)行節(jié)點初始化相關(guān)的處理
        //尾節(jié)點為空，則初始化隊列
        if (p == null) { // initialize queue
            WNode hd = new WNode(WMODE, null);
            if (U.compareAndSwapObject(this, WHEAD, null, hd))
                wtail = hd;
        }
        //初始化代表當(dāng)前讀線程的節(jié)點
        else if (node == null)
            node = new WNode(RMODE, p);
        //head==tail或者隊列tail.mode不為讀狀態(tài)，
        //那么將當(dāng)前線程的節(jié)點node加入到隊列尾部并跳出外層循環(huán)    
        else if (h == p || p.mode != RMODE) {
            if (node.prev != p)
                node.prev = p;
            else if (U.compareAndSwapObject(this, WTAIL, p, node)) {
                p.next = node;
                break;
            }
        }
        //如果head!= tail說明隊列中已經(jīng)有線程在等待或者tail.mode是讀狀態(tài)RMODE，
        //那么CAS方式將當(dāng)前線程的節(jié)點node加入到tail節(jié)點的cowait鏈中
        else if (!U.compareAndSwapObject(p, WCOWAIT,
                                         node.cowait = p.cowait, node))
            node.cowait = null;
        else {
            for (;;) {
                WNode pp, c; Thread w;
                ////如果head不為空那么嘗試去解放head的cowait鏈中的節(jié)點
                if ((h = whead) != null && (c = h.cowait) != null &&
                    U.compareAndSwapObject(h, WCOWAIT, c, c.cowait) &&
                    (w = c.thread) != null) // help release
                    U.unpark(w);
                //如果tail節(jié)點的前驅(qū)就是head或者h(yuǎn)ead==tail或者tail節(jié)點的前驅(qū)是null
                //也就是說當(dāng)前node所在的節(jié)點（因為node可能在cowait鏈中）
                //的前驅(qū)就是head或者h(yuǎn)ead已經(jīng)被釋放了為null    
                if (h == (pp = p.prev) || h == p || pp == null) {
                    long m, s, ns;
                    do {
                        //如果沒有寫狀態(tài)被占有那么自旋方式嘗試獲取讀狀態(tài)，成功則返回stamp
                        if ((m = (s = state) & ABITS) < RFULL ?
                            U.compareAndSwapLong(this, STATE, s,
                                                 ns = s + RUNIT) :
                            (m < WBIT &&
                             (ns = tryIncReaderOverflow(s)) != 0L))
                            return ns;
                    } while (m < WBIT);
                }
                //判斷是否穩(wěn)定
                if (whead == h && p.prev == pp) {
                    long time;
                    //如果tail的前驅(qū)是null或者h(yuǎn)ead==tail或者tail已經(jīng)被取消了(p.status > 0)
                    //直接將node置為null跳出循環(huán)，回到最開的for循環(huán)中去再次嘗試獲取同步狀態(tài)
                    if (pp == null || h == p || p.status > 0) {
                        node = null; // throw away
                        break;
                    }
                    if (deadline == 0L)
                        time = 0L;
                    //如果超時則取消當(dāng)前線程    
                    else if ((time = deadline - System.nanoTime()) <= 0L)
                        return cancelWaiter(node, p, false);
                    Thread wt = Thread.currentThread();
                    U.putObject(wt, PARKBLOCKER, this);
                    node.thread = wt;
                    
                    //tail的前驅(qū)不是head或者當(dāng)前只有寫線程獲取到同步狀態(tài)
                    //判斷穩(wěn)定性
                    if ((h != pp || (state & ABITS) == WBIT) &&
                        whead == h && p.prev == pp)
                        U.park(false, time);
                    node.thread = null;
                    U.putObject(wt, PARKBLOCKER, null);
                    //中斷的話取消
                    if (interruptible && Thread.interrupted())
                        return cancelWaiter(node, p, true);
                }
            }
        }
    }

     //如果隊列中沒有節(jié)點或者tail的mode是WMODE寫狀態(tài)，
     //那么node被加入到隊列的tail之后進(jìn)入這個循環(huán)
    for (int spins = -1;;) {
        WNode h, np, pp; int ps;
        //如果p(node的前驅(qū)節(jié)點)就是head，那么自旋方式嘗試獲取同步狀態(tài)
        if ((h = whead) == p) {
            //第一次循環(huán)，設(shè)置自旋次數(shù)
            if (spins < 0)
                spins = HEAD_SPINS;
            //自旋次數(shù)增加    
            else if (spins < MAX_HEAD_SPINS)
                spins <<= 1;
            for (int k = spins;;) { // spin at head
                long m, s, ns;
                //自旋方式嘗試獲取同步狀態(tài)
                //獲取成功的話將node設(shè)置為head并解放node的cowait鏈中的節(jié)點并返回stamp
                if ((m = (s = state) & ABITS) < RFULL ?
                    U.compareAndSwapLong(this, STATE, s, ns = s + RUNIT) :
                    (m < WBIT && (ns = tryIncReaderOverflow(s)) != 0L)) {
                    WNode c; Thread w;
                    whead = node;
                    node.prev = null;
                    while ((c = node.cowait) != null) {
                        if (U.compareAndSwapObject(node, WCOWAIT,
                                                   c, c.cowait) &&
                            (w = c.thread) != null)
                            U.unpark(w);
                    }
                    return ns;
                }
                //如果有寫線程獲取到了同步狀態(tài)(因為可能有寫線程闖入)那么隨機(jī)的--k控制循環(huán)次數(shù)
                else if (m >= WBIT &&
                         LockSupport.nextSecondarySeed() >= 0 && --k <= 0)
                    break;
            }
        }
        //如果head不為null，解放head的cowait鏈中的節(jié)點
        else if (h != null) {
            WNode c; Thread w;
            while ((c = h.cowait) != null) {
                if (U.compareAndSwapObject(h, WCOWAIT, c, c.cowait) &&
                    (w = c.thread) != null)
                    U.unpark(w);
            }
        }
         //判斷穩(wěn)定性
        if (whead == h) {
            if ((np = node.prev) != p) {
                if (np != null)
                    (p = np).next = node;   // stale
            }
            //嘗試設(shè)tail的狀態(tài)位WAITING表示后面還有等待的節(jié)點
            else if ((ps = p.status) == 0)
                U.compareAndSwapInt(p, WSTATUS, 0, WAITING);
            //如果tail已經(jīng)取消了    
            else if (ps == CANCELLED) {
                if ((pp = p.prev) != null) {
                    node.prev = pp;
                    pp.next = node;
                }
            }
            else {
                //超時判定
                long time;
                if (deadline == 0L)
                    time = 0L;
                else if ((time = deadline - System.nanoTime()) <= 0L)
                    return cancelWaiter(node, node, false);
                Thread wt = Thread.currentThread();
                U.putObject(wt, PARKBLOCKER, this);
                node.thread = wt;
                //阻塞等待
                if (p.status < 0 &&
                    (p != h || (state & ABITS) == WBIT) &&
                    whead == h && node.prev == p)
                    U.park(false, time);
                node.thread = null;
                U.putObject(wt, PARKBLOCKER, null);
                //中斷處理
                if (interruptible && Thread.interrupted())
                    return cancelWaiter(node, node, true);
            }
        }
    }
}

讀鎖釋放：

public void unlockRead(long stamp) {
    long s, m; WNode h;
    for (;;) {
        //寫計數(shù)相關(guān)的bit位有改變，或讀計數(shù)相關(guān)的bit位為0，或有寫鎖，則異常
        if (((s = state) & SBITS) != (stamp & SBITS) ||
            (stamp & ABITS) == 0L || (m = s & ABITS) == 0L || m == WBIT)
            throw new IllegalMonitorStateException();
        //讀鎖計數(shù)未溢出？    
        if (m < RFULL) {
            if (U.compareAndSwapLong(this, STATE, s, s - RUNIT)) {
                if (m == RUNIT && (h = whead) != null && h.status != 0)
                    release(h);
                break;
            }
        }
       //讀鎖計數(shù)溢出？    
        else if (tryDecReaderOverflow(s) != 0L)
            break;
    }
}

2.6、樂觀鎖獲取

public long tryOptimisticRead() {
    long s;
    //當(dāng)無寫鎖，則返回（state & SBITS），即高位的寫計數(shù)；
    //否則返回0，即獲取樂觀鎖失敗
    return (((s = state) & WBIT) == 0L) ? (s & SBITS) : 0L;
}

2.7、鎖模式的轉(zhuǎn)換

轉(zhuǎn)換為寫鎖：將其他模式（如寫鎖、讀鎖、樂觀鎖）的鎖轉(zhuǎn)換為寫鎖

public long tryConvertToWriteLock(long stamp) {
    long a = stamp & ABITS, m, s, next;
    //寫鎖的狀態(tài)未變？
    while (((s = state) & SBITS) == (stamp & SBITS)) {
        //當(dāng)前無寫/讀鎖？CAS獲取寫鎖
        if ((m = s & ABITS) == 0L) {
            if (a != 0L)
                break;
            if (U.compareAndSwapLong(this, STATE, s, next = s + WBIT))
                return next;
        }
        //當(dāng)前有寫鎖，且狀態(tài)不變，則直接返回原本的版本郵戳
        else if (m == WBIT) {
            //寫線程不為當(dāng)前線程？錯誤，跳出循環(huán)
            if (a != m)
                break;
            return stamp;
        }
        //無寫鎖，有一個讀鎖，即當(dāng)前線程為獲取讀鎖的線程
        //直接cas將讀鎖釋放并獲取寫鎖，即state=（state - RUNIT + WBIT）
        else if (m == RUNIT && a != 0L) {
            if (U.compareAndSwapLong(this, STATE, s,
                                     next = s - RUNIT + WBIT))
                return next;
        }
        //當(dāng)還有其他線程獲取讀鎖時，自旋等待其他讀鎖釋放
        else
            break;
    }
    return 0L;
}

主要處理：
當(dāng)鎖狀態(tài)為無讀/寫鎖時，通過CAS獲取寫鎖；
當(dāng)當(dāng)前線程已獲取寫鎖時，直接返回原本的郵戳；
當(dāng)只有一個讀鎖，即當(dāng)只有當(dāng)前線程獲取讀鎖，沒有其他的讀鎖時，CAS釋放讀鎖并獲取寫鎖；
當(dāng)獲取讀鎖的線程數(shù)大于1，即除當(dāng)前線程還有其他線程也獲取到讀鎖時，自旋等待其他讀鎖釋放；

轉(zhuǎn)換為讀鎖：將讀/寫鎖轉(zhuǎn)換為讀鎖；

public long tryConvertToReadLock(long stamp) {
    long a = stamp & ABITS, m, s, next; WNode h;
    //無寫鎖？
    while (((s = state) & SBITS) == (stamp & SBITS)) {
        
        //無讀/寫鎖，則CAS獲取讀鎖
        if ((m = s & ABITS) == 0L) {
            //郵戳錯誤？退出循環(huán)
            if (a != 0L)
                break;
            //讀鎖計數(shù)未溢出？    
            else if (m < RFULL) {
                if (U.compareAndSwapLong(this, STATE, s, next = s + RUNIT))
                    return next;
            }
            //讀鎖計數(shù)溢出？
            else if ((next = tryIncReaderOverflow(s)) != 0L)
                return next;
        }
        //有寫鎖，且寫鎖為當(dāng)前線程？則釋放讀鎖并喚醒后續(xù)寫鎖線程
        else if (m == WBIT) {
            //寫鎖不為當(dāng)前線程，錯誤，跳出循環(huán)
            if (a != m)
                break;
            state = next = s + (WBIT + RUNIT);
            if ((h = whead) != null && h.status != 0)
                release(h);
            return next;
        }
        //當(dāng)前線程已經(jīng)獲取得讀鎖？
        else if (a != 0L && a < WBIT)
            return stamp;
        else
            break;
    }
    return 0L;
}

主要處理：
若無讀/寫鎖，則CAS獲取讀鎖；
若寫鎖為當(dāng)前線程，則CAS釋放寫鎖并獲取讀鎖；
若當(dāng)前線程已經(jīng)獲取讀鎖，則返回原本的郵戳；

轉(zhuǎn)換為樂觀鎖：

public long tryConvertToOptimisticRead(long stamp) {
    long a = stamp & ABITS, m, s, next; WNode h;
    U.loadFence();
    for (;;) {
        //寫鎖狀態(tài)變更？
        if (((s = state) & SBITS) != (stamp & SBITS))
            break;
        //無讀/寫鎖？直接返回state    
        if ((m = s & ABITS) == 0L) {
            if (a != 0L)
                break;
            return s;
        }
        //已經(jīng)獲取寫鎖？則直接釋放寫鎖
        else if (m == WBIT) {
            if (a != m)
                break;
            state = next = (s += WBIT) == 0L ? ORIGIN : s;
            if ((h = whead) != null && h.status != 0)
                release(h);
            return next;
        }
        //狀態(tài)為無讀鎖或無寫鎖？
        else if (a == 0L || a >= WBIT)
            break;
        //讀鎖計數(shù)未溢出    
        else if (m < RFULL) {
            if (U.compareAndSwapLong(this, STATE, s, next = s - RUNIT)) {
                if (m == RUNIT && (h = whead) != null && h.status != 0)
                    release(h);
                return next & SBITS;
            }
        }
        //讀鎖計數(shù)溢出？
        else if ((next = tryDecReaderOverflow(s)) != 0L)
            return next & SBITS;
    }
    return 0L;
}

主要處理：
若當(dāng)前線程已經(jīng)獲取寫鎖，則直接釋放寫鎖；
若當(dāng)前線程已經(jīng)獲取讀鎖，則CAS釋放讀鎖；
當(dāng)鎖時，返回狀態(tài)值state；