ReentrantLock源码了解

Posted 2020-08-09 qingyezhu

    1）、ReentrantLock.tryLock
    //获取没有被其他线程持有的锁
    //1）、当没有被任何线程持有时，首先将计数器设置为1，并设置当前持有锁的线程为当前线程，最后返回true
    //2）、当被当前线程持有时，将计数器加1，最后返回true；
    //3）、否则返回false
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

    //接着直接调用抽象类中的Sync.nonfairTryAcquire
    final boolean nonfairTryAcquire(int acquires) {
        //获取当前调用线程
        final Thread current = Thread.currentThread();
        //获取当前锁的状态，也就是当前锁的计数器的数值
        int c = getState();
        if (c == 0) {
            //此时说明，当前锁没有被任何线程持有
            if (compareAndSetState(0, acquires)) {
                //使用CAS操作，更新锁的状态，即锁的计数器的数值，若是成功，则将当前锁的线程持有者设置为当前线程
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        else if (current == getExclusiveOwnerThread()) {
            //根据JMM模型可知，同一个工作内存内是可见的，故同一个线程内是可见的，若相等，是同一个线程，且在同一个线程内不会发生setExclusiveOwnerThread时，在getExclusiveOwnerThread得到的不一样
            //此时说明，当前锁的线程持有者是当前线程
            //设置锁的计数器的值
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            //更新锁的状态，即锁的计数值的数值
            setState(nextc);
            return true;
        }
        return false;
    }

    2）、ReentrantLock.unlock
    //试图释放锁
    //1）、当前线程不是该锁的持有者时，抛出异常
    //2）、当前锁的计数器更改为0时，则设置当前锁的持有者为null
    //3）、否则，更新当前锁的状态，即锁的计数器的数值
    public void unlock() {
        sync.release(1);
    }

    //接着直接调用抽象类AbstractQueuedSynchronizer.release
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            //当锁的状态为0，或者说当前锁没有持有者时，需要唤醒当前锁上挂起的线程
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

    //再接着直接调用抽象类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) {
            //当计数器的数值为0，说明此时锁没有持有者了，故先更新线程持有者，之后再去更新锁的状态，这样当去获取锁的状态时，此时的锁的持有者必然是更新后的，这样锁的释放和锁的获取就能保证一致的可见性了。
            free = true;
            setExclusiveOwnerThread(null);
        }
        //更新锁的状态，即锁的计数器的数值
        setState(c);
        return free;
    }

    //直接调用AbstractQueuedSynchronizer.unparkSuccessor
    //唤醒当前节点后的第一个非取消节点中的线程
    private void unparkSuccessor(Node node) {
        
        //尝试更新当前节点的状态
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        //获取当前节点后的第一个非取消节点，并唤醒该节点中挂起的线程
        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);
    }

    3）、ReentrantLock.lock
    //申请锁
    public void lock() {
       sync.lock();
    }

    31）、非公平锁
    //直接调用NonfairSync.lock
    final void lock() {
        //当通过CAS判断当前锁是否没有持有者，若是，则直接设置当前锁的持有者为当前线程；
        //否则，再次尝试加锁，最后还不成功，就如等待队列，线程挂起，直到被唤醒为止
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

    //直接调用AbstractQueuedSynchronizer.acquire
    public final void acquire(int arg) {
        //尝试获取非公平锁，当失败时，就将当前线程入等待队列，线程挂起，直到被挂起
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

    //直接调用NonfairSync.tryAcquire
       protected final boolean tryAcquire(int acquires) {
           //尝试获取非公平锁
        return nonfairTryAcquire(acquires);
    }

    //直接调用AbstractQueuedSynchronizer.addWaiter
    //将排他锁节点添加到链表尾部
    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            //当前链表已经初始化，则CAS尝试将排他锁节点更改为链表的尾节点

            //设置当前节点的前一个节点为当前链表的尾节点
            node.prev = pred;
            //当CAS尝试更新尾节点成功，则将新尾节点的前一个节点的下一个节点更新为新的尾节点
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

    //直接调用AbstractQueuedSynchronizer.compareAndSetTail
    //原子更新链表的尾节点
    private final boolean compareAndSetTail(Node expect, Node update) {
        return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
    }

    //直接调用AbstractQueuedSynchronizer.enq
    //使用CAS原子性将节点插入到链表尾部
    private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                //当没有初始化时，进行头结点与尾节点初始化，成功后，将头结点与尾节点指向同一个处对象
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                //将节点插入到链表尾部

                //设置当前节点的前一个节点为当前链表的尾节点
                node.prev = t;
                //当CAS尝试更新尾节点成功，则将新尾节点的前一个节点的下一个节点更新为新的尾节点
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

    //直接调用AbstractQueuedSynchronizer.acquireQueued
    //当当前节点为等待队列中的第一个节点时，获取到锁
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                //当当前节点的前节点为头结点，并为当前线程尝试获取锁，成功时，设置当前节点为头结点，并将当前节点的前节点的下一个节点取消，使之没有被引用，这样可以被GC回收
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }    
                //设置当前节点的前节点状态为唤醒状态，且将当前节点挂起
                if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    //直接调用AbstractQueuedSynchronizer.setHead
    //设置当前节点为头结点，并将当前节点的前节点置为空，以及将当前节点持有的线程设置为空
    private void setHead(Node node) {
        head = node;
        node.thread = null;
        node.prev = null;
    }

    //直接调用AbstractQueuedSynchronizer.shouldParkAfterFailedAcquire
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            //当当前节点的前节点状态为唤醒时，则表明下一个被执行的节点是当前节点，即线程会被唤醒
            return true;
        if (ws > 0) {
               //当当前节点的前节点为取消的节点，则往前查找一个非取消的节点
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            //将查找的非取消节点的下一个节点更新为当前节点
            pred.next = node;
        } else {
            //尝试将当前节点的前节点的状态设置为唤醒状态
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

    //直接调用AbstractQueuedSynchronizer.compareAndSetWaitStatus
       //尝试更新节点的状态
    private static final boolean compareAndSetWaitStatus(Node node, int expect, int update) {
        return unsafe.compareAndSwapInt(node, waitStatusOffset, expect, update);
    }

    //直接调用AbstractQueuedSynchronizer.parkAndCheckInterrupt
    //将当前线程挂起
    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }