阅读AQS及其衍生类Semaphore、CountDownLatch、ReentantLock等源码的感悟

曾今阅读过AQS,Semaphore,CountDownLatch,ReentantLock,等并发包的源码，其中后面三个类都是基于AQS实现的,AQS是同步框架的基石，不同的衍生类可以实现tryAcquireShared（主要共享锁实现）tryReleaseShared（主要共享锁实现）tryAcquire(独占锁实现)，tryRelease（独占锁实现），以此来实现不同的并发框架，来满足不同的需求，那么到底这些如方法代表着什么意思呢，我们可以从线程的角度来思考，当线程碰到Semaphore,CountLatch,ReentantLock这些类的（acquire,await,lock）,就线程而言就只有两种情况，要么继续运行，要么阻塞等待，而不同的衍生类则通过实现tryAquire来实现这一目的的，比如：

对于ReentantLock，其tryAcquire实现如下 通过这一方式来控制线程是否应该通过，从而实现独占重入锁
         protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                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;
        }
    }

 

有比如对于Semaphore,调用此方法，来决定一个线程是否放行
    
      protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
        // 尝试获取资源，可用的减去自己获取的大于0,并CAS成功就返回
     final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }
    

 

而对于AQS的tryRelease（独占锁实现）,tryReleaseShared（主要共享锁实现）方法则主要判断是否应该尝试唤醒线程（这很自然，因为在tryAcquire等方法中会阻塞线程） 比如对于ReentantLock则调用下面方法来决定是否应该尝试唤醒线程，已达到同时只有一个线程能够运行，当ture才尝试唤醒，

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

 

而对于Semaphore则调用tryReleaseShared，来决定是否应该唤醒线程

protected final boolean tryReleaseShared(int releases) {
            for (;;) {
                int current = getState();
                int next = current + releases;
                if (next < current) // overflow
                    throw new Error("Maximum permit count exceeded");
                if (compareAndSetState(current, next))
                    return true;
            }
        }