JUC并發(fā)編程之ReentrantLock非公平鎖源碼詳解

// 標(biāo)識(shí)拿到鎖的是哪個(gè)線程private transient Thread exclusiveOwnerThread;

// 標(biāo)識(shí)頭節(jié)點(diǎn)private transient volatile Node head;// 標(biāo)識(shí)尾節(jié)點(diǎn)private transient volatile Node tail;// 同步狀態(tài)，為0時(shí)，說(shuō)明可以搶鎖private volatile int state;

// 記錄Node狀態(tài)volatile int waitStatus;// 標(biāo)識(shí)Node是哪個(gè)線程所持有volatile Node prev;// 前驅(qū)節(jié)點(diǎn)（當(dāng)前Node的上一個(gè)是誰(shuí)）volatile Node next;// 后繼節(jié)點(diǎn)（當(dāng)前Node的個(gè)一個(gè)是誰(shuí)）volatile Thread thread;

public class ReentrantLockTest {    // 初始化Lock類    static final Lock lock = new ReentrantLock();    static int sum = 0;    public static void main(String[] args) throws InterruptedException {        for (int i = 0; i < 3; i++) {            Thread thread = new Thread(new Runnable() {                @Override                public void run() {                    try {                        // 獲取鎖                        lock.lock();                        for (int i1 = 0; i1 < 10000; i1++) {                            sum++;                        }                    } catch (Exception e) {                        e.printStackTrace();                    } finally {                        //釋放鎖                        lock.unlock();                    }                }            });            thread.start();        }        TimeUnit.SECONDS.sleep(1);        System.out.println(sum);    }}

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

static final class NonfairSync extends Sync {    private static final long serialVersionUID = 7316153563782823691L;    /**     * Performs lock.  Try immediate barge, backing up to normal     * acquire on failure.     */    final void lock() {        //以cas的方式將AQS中的state屬性值從0更新為1        if (compareAndSetState(0, 1))            //如果更新成功,則將當(dāng)前線程設(shè)置為持有鎖的線程            setExclusiveOwnerThread(Thread.currentThread());        else            //獲取鎖失敗,則進(jìn)入該方法            acquire(1);    }    protected final boolean tryAcquire(int acquires) {        return nonfairTryAcquire(acquires);    }}

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

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

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

protected final boolean tryAcquire(int acquires) {    return nonfairTryAcquire(acquires);}

final boolean nonfairTryAcquire(int acquires) {    //記錄當(dāng)前線程    final Thread current = Thread.currentThread();    //獲取當(dāng)前state的值    int c = getState();    //如果state的值為0,則證明沒(méi)有線程搶占鎖    if (c == 0) {        // 通過(guò)cas進(jìn)行加鎖操作        if (compareAndSetState(0, acquires)) {            // 記錄加鎖線程            setExclusiveOwnerThread(current);            return true;        }    }    // 如果鎖已經(jīng)被搶占，且當(dāng)前線程就是持有鎖的線程，則說(shuō)明該鎖被重入    else if (current == getExclusiveOwnerThread()) {        //計(jì)算要更新后的state值        int nextc = c + acquires;        if (nextc < 0) // overflow            throw new Error("Maximum lock count exceeded");        //給state設(shè)置值，該方式為非同步        setState(nextc);        //重入鎖獲取成功        return true;    }    //獲取鎖失敗    return false;}

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

private Node addWaiter(Node mode) {    //創(chuàng)建一個(gè)節(jié)點(diǎn)，將線程實(shí)例封裝到Node節(jié)點(diǎn)內(nèi)部，當(dāng)前mode這里是為null的    Node node = new Node(Thread.currentThread(), mode);    // Try the fast path of enq; backup to full enq on failure     //獲取末尾節(jié)點(diǎn)    Node pred = tail;    //如果末尾節(jié)點(diǎn)不為空,則證明前面已經(jīng)有線程排隊(duì)啦    if (pred != null) {        //將末尾節(jié)點(diǎn)的引用交給當(dāng)前線程的前節(jié)點(diǎn)        node.prev = pred;        // 通過(guò)cas,將當(dāng)前線程設(shè)置為鏈表的尾節(jié)點(diǎn)        if (compareAndSetTail(pred, node)) {            // 將前尾節(jié)點(diǎn)的next引用,指向當(dāng)前節(jié)點(diǎn),那么當(dāng)前節(jié)點(diǎn)就是鏈表尾節(jié)點(diǎn)了            pred.next = node;            return node;        }    }    //構(gòu)建鏈表核心方法    enq(node);    return node;}

private Node enq(final Node node) {        //自旋        for (;;) {            //獲取當(dāng)前雙向鏈表的末尾節(jié)點(diǎn)            Node t = tail;            //如果當(dāng)前還沒(méi)有雙向鏈表，則進(jìn)行構(gòu)建鏈表            if (t == null) { // Must initialize                //初始化一個(gè)head節(jié)點(diǎn)，空的node節(jié)點(diǎn)                if (compareAndSetHead(new Node()))                    //將head節(jié)點(diǎn)賦值給tail節(jié)點(diǎn)，這樣的頭尾節(jié)點(diǎn)都已生成好了                    tail = head;            } else {                //自旋第二次會(huì)進(jìn)來(lái)                //頭節(jié)點(diǎn)設(shè)置為 空節(jié)點(diǎn)                node.prev = t;                //通過(guò)cas,將當(dāng)前節(jié)點(diǎn)設(shè)置為末尾節(jié)點(diǎn)                if (compareAndSetTail(t, node)) {                    //設(shè)置尾節(jié)點(diǎn)引用                    t.next = node;                    return t;                }            }        }    }

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

 //Node: 為線程1的節(jié)點(diǎn)   arg:1final boolean acquireQueued(final Node node, int arg) {    boolean failed = true;    try {        boolean interrupted = false;        //只有獲取到鎖的線程才會(huì)跳出循環(huán)        for (;;) {            //獲取當(dāng)前線程節(jié)點(diǎn)的 prev 節(jié)點(diǎn)            final Node p = node.predecessor();             // 第二個(gè)線程 第一個(gè)條件為true , 第二個(gè)條件為false,因?yàn)榈诙€(gè)條件是 搶鎖邏輯            if (p == head && tryAcquire(arg)) {                setHead(node); //將當(dāng)前節(jié)點(diǎn)更新為頭節(jié)點(diǎn)                p.next = null; // help GC                failed = false;                return interrupted; //正常情況下死循環(huán)的唯一出口            }             // 將上一個(gè)節(jié)點(diǎn)設(shè)置為獨(dú)占鎖-1,條件返回fasle，第二次自旋進(jìn)來(lái)            if (shouldParkAfterFailedAcquire(p, node) && //判斷線程是否需要被阻塞                //阻塞當(dāng)前線程                parkAndCheckInterrupt())                interrupted = true;        }    } finally {        if (failed)            cancelAcquire(node);    }}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {    int ws = pred.waitStatus;    if (ws == Node.SIGNAL) //狀態(tài)為SIGNAL        /*         * This node has already set status asking a release         * to signal it, so it can safely park.         */        return true;    if (ws > 0) {   //狀態(tài)為CANCELLED        /*         * Predecessor was cancelled. Skip over predecessors and         * indicate retry.         */        do {            node.prev = pred = pred.prev;        } while (pred.waitStatus > 0);        pred.next = node;    } else {   //狀態(tài)為初始化狀態(tài)(ReentrentLock語(yǔ)境下)        /*         * waitStatus must be 0 or PROPAGATE.  Indicate that we         * need a signal, but don't park yet.  Caller will need to         * retry to make sure it cannot acquire before parking.         */        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);    }    return false;}

private final boolean parkAndCheckInterrupt() {    LockSupport.park(this);    return Thread.interrupted();}

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

public final boolean release(int arg) {    if (tryRelease(arg)) {        Node h = head;        if (h != null && h.waitStatus != 0)            unparkSuccessor(h);        return true;    }    return false;}

protected final boolean tryRelease(int releases) {    int c = getState() - releases; //計(jì)算待更新的state值    if (Thread.currentThread() != getExclusiveOwnerThread())        throw new IllegalMonitorStateException();    boolean free = false;    if (c == 0) {  //待更新的state值為0,說(shuō)明持有鎖的線程未重入,一旦釋放鎖其他線程將能獲取        free = true;        setExclusiveOwnerThread(null);  //清除鎖的持有線程標(biāo)記    }    setState(c);  //更新state值    return free;}

public final boolean release(int arg) {    if (tryRelease(arg)) {        Node h = head;        if (h != null && h.waitStatus != 0)            unparkSuccessor(h);        return true;    }    return false;}

private void unparkSuccessor(Node node) {    // 先獲取head節(jié)點(diǎn)的狀態(tài)，應(yīng)該是等于-1，原因在shouldParkAfterFailedAcquire方法中有體現(xiàn)    int ws = node.waitStatus;     // 由于-1會(huì)小于0，所以更新改為0    if (ws < 0)        compareAndSetWaitStatus(node, ws, 0);    // 獲取第一個(gè)正常排隊(duì)的節(jié)點(diǎn)    Node s = node.next;     //正常解鎖流程不會(huì)走該if判斷    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;    }     // 正常來(lái)說(shuō)第一個(gè)排隊(duì)的節(jié)點(diǎn)不應(yīng)該為空，所以直接把第一個(gè)排隊(duì)的線程喚醒    if (s != null)        LockSupport.unpark(s.thread);}

private final boolean parkAndCheckInterrupt() {    LockSupport.park(this);    return Thread.interrupted();}