ReentrantLock&&AQS源码分析(部分)

• ReentrantLock可重入锁，内部类Sync继承AQS，Sync有两个子类，分别为NonfairSync和FairSync。ReentrantLock锁为排它锁，使用它可以有效解决死锁问题。分析类关系图,ReentrantLock实现了Lock和Serializable接口,Syn做为ReentrantLock的一个内部类,我们从Sync开始看起

• Sync

//继承AQS
abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        //由子类NonfairSync和FairSync去实现
        abstract void lock();

        //非公平抢占锁
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            //锁状态
            int c = getState();
            //为0，尝试获取锁。如果当前线程的等待线程队列
            //没有前驱&&cas设置锁成功，那么设置当前线程为锁持有者
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //如果c！=0，并且当前线程是锁持有者，那说明是
            //重新获取锁（重入锁），锁次数增加
            else if (current == getExclusiveOwnerThread()) {
                //获取🔒锁次数增加
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            //本次获取锁🔒失败
            return false;
        }

		//释放锁🔒
        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            //当前线程不是锁🔒拥有者，抛出异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            //为0，释放成功
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            //设置最新状态值，大于等于0
            setState(c);
            return free;
        }

       //其他方法略...
    }

• NonfairSync非公平同步

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        //加锁🔒
        final void lock() {
            //cas尝试获取锁🔒
            if (compareAndSetState(0, 1))
                //成功，设置锁拥有者线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                //失败，尝试获取,调用AQS中的acquire(int)方法
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            //非公平尝试获取锁🔒资源
            return nonfairTryAcquire(acquires);
        }
    }

• AQS部分方法

    public final void acquire(int arg) {
        //尝试获取锁，如果尝试获取锁失败&&尝试加入等待队列成功
        //tryAcquire为模板方法，需要继承的子类重写
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            //调用Thread.currentThread().interrupt();
            selfInterrupt();
    }
    
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            //进入自旋
            for (;;) {
                //获取当前节点的前驱
                final Node p = node.predecessor();
                //前驱节点就是头节点&&尝试获取锁成功
                //头节点表示获取锁成功的节点记录
                if (p == head && tryAcquire(arg)) {
                    //更新队列头节点为当前节点
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    //获取锁成功，返回interrupted标识为false
                    return interrupted;
                }
                //如果当前线程为可park&&则park并且检查当前线程的interrupt标识
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL) //ws==-1
            //前驱节点ws状态为可通知，则返回true，应该park
            return true;
        if (ws > 0) { //ws==1
            //前驱节点放弃获取锁,则顺序想前找为放弃的节点pred = pred.prev
            //找到赋值给当前节点的前驱node.prev =()
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else { //ws==-2|ws==-3
            //设置ws状态,当前节点的前驱节点状态设置为SIGNAL
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        //不应该park
        return false;
    }
    
    //当前线程park，并且返回当前线程interrupt标志
    private final boolean parkAndCheckInterrupt() {
        //当前线程park
        LockSupport.park(this);
        //返回当前线程interrupt标志，并且重置状态为false(未打断状态)
        return Thread.interrupted();
    }
    //park
    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }

• FairSync 公平同步

    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
        //加锁
        final void lock() {
            acquire(1);
        }
        //公平获取锁
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                //判断没有hasQueuedPredecessors的情况下获取锁
                //公平！！！
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //同非公平锁,略...
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }