ReadWriteLock源码阅读之WriteLock加锁解锁过程源码分析

写的有点乱，因为无论是ReadWriteLock还是ReentrantLock加锁解锁过程本身就很乱。
只写了lock方法，lockInterruptibly方法其实和lock差不多，只是再睡眠的时候被打断了醒来后发现被打断了就抛出了一个异常，其余没什么差别。
首先读写锁也是有公平和非公平之分。这一点要注意。默认是非公平锁。

加锁

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

tryAcquire方法

protected final boolean tryAcquire(int acquires) {
            /*
             * Walkthrough:
             * 1. If read count nonzero or write count nonzero
             *    and owner is a different thread, fail.
             * 2. If count would saturate, fail. (This can only
             *    happen if count is already nonzero.)
             * 3. Otherwise, this thread is eligible for lock if
             *    it is either a reentrant acquire or
             *    queue policy allows it. If so, update state
             *    and set owner.
             */
             //当前线程
            Thread current = Thread.currentThread();
            //是否上锁
            int c = getState();
            int w = exclusiveCount(c);
            //因为写锁是互斥锁，只要有读锁或者写锁都不能上锁成功
            //除非重入，c！=0表示已经有人上锁了
            if (c != 0) {
                // (Note: if c != 0 and w == 0 then shared count != 0)
                // 如果w == 0 表示没有人加写锁，此时是读锁,只有
                // 重入可以枷锁成功。			                       
                //不过我不推荐读写锁读锁升级为写锁，会导致死锁。
                //因为互斥，所以只要线程不相同不能重入，就返回false
                if (w == 0 || current != getExclusiveOwnerThread())
                    return false;
                //重入的情况，大于重入的最大值直接溢出报错。
                if (w + exclusiveCount(acquires) > MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                //直接上锁，不需要cas，因为这个是重入写锁加写锁情况。
                setState(c + acquires);
                return true;
            }
            //writeShouldBlock方法在下面有介绍
            //当他不需要排队，或者说公平锁情况下，会直接进行cas操作，将c也就是state由0改为1
            //如果加锁失败，整个方法返回false；
            //这个地方主要是当他发现当前无人持有锁，得去看有没有
            //其他线程也在等
            if (writerShouldBlock() ||
                !compareAndSetState(c, c + acquires))
                return false;
            //如果加锁成功，将线程设到AbstractOwnableSynchronizer这个里面去
            setExclusiveOwnerThread(current);
            return true;
        }

exclusiveCount方法

static final int SHARED_SHIFT   = 16;
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
//相当于c与 16个1。这个地方计算的是当前写锁的情况
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

writerShouldBlock 方法

//公平锁，判断自己需不需要排队
final boolean writerShouldBlock() {
			//这个方法我之后如果有时间写ReentrantLock的时候再详细说吧，
			//他其实是aqs里面很经典很重要的一个方法，就是判断自己需不需要排队
            return hasQueuedPredecessors();
        }
//非公平锁，直接抢资源就完事了
final boolean writerShouldBlock() {
            return false; // writers can always barge
        }

addWaiter方法

aqs经典方法

private Node addWaiter(Node mode) {
		//new 出一个node，
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        //拿到aqs的尾节点。
        Node pred = tail;
        //如果尾节点不为null，说明aqs已经被初始化
        if (pred != null) {
        	//就是节点指向，链表维护。
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        //如果尾节点为null，或者cas失败（表示同一个时间点，多个线程cas执行，只成功一个）
        //往下看enq方法
        enq(node);
        return node;
    }

enq方法

aqs经典方法

 private Node enq(final Node node) {
        for (;;) {
        	//拿到尾节点
            Node t = tail;
            //如果为空，则说明队列未初始化
            if (t == null) { // Must initialize
            	//初始化队列。
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
            	//这个和上一个的入队操作一样，注意这个地方是死循环，哪怕几千个
            	//线程同时cas去抢资源，无线循环也会入队完成。
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

acquireQueued 方法

之前这个node已经入队了。

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
            //拿到node的前一个节点
                final Node p = node.predecessor();
            //如果上一个节点是aqs的头节点，再尝试加锁一次，避免park，真牛这代码
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //第一次shouldParkAfterFailedAcquire为false，继续来一次。
                //第二次p.waitstatus变成-1，则准备park了。
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    //解锁成功后，不管是不是false还是true都进入下一轮循环。
                    //去尝试加锁，去竞争。
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

shouldParkAfterFailedAcquire方法

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
		//拿到前一个节点waitStatus默认是0
        int ws = pred.waitStatus;
        //第二次就是-1.返回true
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * 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.
             */
             //将他改成-1退出为false
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

parkAndCheckInterrupt方法

 private final boolean parkAndCheckInterrupt() {
 		//自旋
        LockSupport.park(this);
        //这个其实再这个地方没什么卵子用，lockInterruptibly（）这个方法的时候，后面直接抛异常
        //dog李这里就复用了这一段代码。可读性较差（唯一能蔑视大神的点了哈哈哈）
        //解锁成功后直接返回
        return Thread.interrupted();
    }

解锁

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

release方法

aqs的方法之一

  public final boolean release(int arg) {
  		//把state置为0之后
        if (tryRelease(arg)) {
        	//拿到头节点
            Node h = head;
            //如果头节点的waitStatus ！= 0 就unpark他下一个节点。
            //这里注意，waitStatus 初始化为0，如果不为0，说明
            //有第二个线程把他置为-1 或者什么什么的，说明有人排队
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

tryRelease方法

 protected final boolean tryRelease(int releases) {
 			//解锁的线程不是当前的线程。抛异常。
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            //把之前的写锁的后16位去-1.
            int nextc = getState() - releases;
            //如果这个时候是0，表示没人加锁。
            boolean free = exclusiveCount(nextc) == 0;
            //把持有锁的线程置位null
            if (free)
                setExclusiveOwnerThread(null);
            setState(nextc);
            return free;
        }

unparkSuccessor 方法

aqs方法之一

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;
            //这里我也不清楚为什么循环，可能他只是想waitStatus<0的节点。
            //我猜测之前waitStatus再某个地方某个逻辑（可能是取消的时候）设置成＞0了。
            //果然顺着源码去读，验证猜测。
            /** waitStatus value to indicate thread has cancelled 
        static final int CANCELLED =  1;*/
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        // s != null 就去唤醒他
        if (s != null)
            LockSupport.unpark(s.thread);
    }