AQS实现ReentrantLock和CountLatchDown详解

前言：AQS看懂了，来了解一下ReentrantLock、CountLatchDown大概的实现原理，看这篇文章之前需要把AQS了解清楚，如果不了解可以去看https://blog.csdn.net/q610376681/article/details/108917792。

参考：https://blog.csdn.net/Mutou_ren/article/details/103827337

目录

第一章 基于AQS实现ReentrantLock

1.1 lock

1.2 unlock

第二章 基于AQS实现CountLatchDown

1.1 await

1.2 countDown

 

第三章 ReentrantLock和booleanlock

---

第一章 基于AQS实现ReentrantLock

在ReentrantLock中依靠一个state来表示锁的状态，当state为0表示没有线程获取了锁，当state>0表示有线程获取了锁，数值如果为2表示有线程重入了一次锁，以此类推等等。

private volatile int state;

1.1 lock

在加锁时先尝试用CAS将状态改为1，如果变为了1，则加锁成功，如果并没有改变成功，则尝试获取资源。

final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

 可以看到，流程就转到了AQS非公平锁的获取环节，这里我们不再赘述非公平锁的上锁流程，主要说一下ReentrantLock实现的tryAcquire。

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

 可以看到，如果状态是0，则用CAS尝试更改状态为1，如果更改成功则获取到锁，如果当前线程已持有锁，则将状态加1，若以上都不满足，则返回获取锁失败。

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            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;
        }

 

1.2 unlock

在解锁函数中调用了unlock，unlock调用了release，这里不再对阻塞流程进行说明，主要分析一下tryRelease。

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;
    }

在资源的释放函数中， 如果当前线程没获得锁则抛出异常，如果获取了锁则将状态值减一，如果减完后状态值变成了0，则表示已没有线程获得锁，并返回释放资源成功，如果没变成0，则返回释放资源失败。

protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

 

 

第二章 基于AQS实现CountLatchDown

先看一下CountLatchDown的使用，这个我懒得敲了，直接复制这位博主的了，https://blog.csdn.net/Mutou_ren/article/details/103827337，大概看一下就行。

这个类的作用大致就是创建CountLatchDown时传入一个数值假设为a，调用await会阻塞调用的线程，当调用a次countDown()函数后，被阻塞的线程恢复执行。

状态值表示的是还有几个在运行的线程，每运行完一个线程调用一次countDown使状态值减一，当状态值被减成0的时候，被阻塞的线程恢复运行。

public class TestCountDownLatch {

    public static CountDownLatch countDownLatch = new CountDownLatch(3);

    public static void main(String[] args) throws InterruptedException {
        for (int i=0;i<3;i++){
            new Thread(new Task()).start();
        }
        System.out.println("线程启动结束，主线程进入等待状态");
        countDownLatch.await();
        System.out.println("主线程结束");
    }
}

class Task implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName()+" task ");
            TestCountDownLatch.countDownLatch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

1.1 await

大致就是调用await会去请求共享资源，根据状态值是否为0来决定是否能获取到资源，当状态值为0时获取资源成功，如果请求共享资源失败则阻塞线程。

public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }
​
protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }


private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

1.2 countDown

可以看到当调用countDown的时候，状态值将会被减一，如果减完后状态值为0，则返回true表示释放成功，

public void countDown() {
        sync.releaseShared(1);
    }

public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }

释放成功后则会调用doReleaseShared唤醒后面的线程。

private void doReleaseShared() {
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }

 

第三章 ReentrantLock和booleanlock

在这里说一下booleanlock，这个是我看Java高并发编程详解看到的，它用wait和notify比较简短的代码实现了ReentrantLock的功能，而ReentrantLock的实现是基于AQS的，正常情况下面试官问ReentrantLock的实现原理都是在问基于AQS的那种，关于booleanlock使用wait和notify实现的ReentrantLock感兴趣的可以参考：

https://blog.csdn.net/q610376681/article/details/107755183   3.1章