AQS入门

本文详细介绍AQS相关的知识

概述

　　AQS全称：Abstract Quened Synchronizer

思路

　　1.学习AQS的主要目的是了解其原理

　　2.提供自我技术水平

　　3.应对面试

　　4.先了解其场景，再学习如何使用，再掌握其原理

为什么要学习AQS

　　我们发现ReentrantLock和Semaphore有个共同的特点，即为闸门，都有协作，提取其工具类变成了AQS

同步类和AQS的关系

　　Semaphore与AQS关系如下图所示：

　　

 

 

　　CountDownLatch为AQS关系如下图所示：

　　

 

 

　　ReentrantLock与AQS关系如下图：

　　

 重要性

　　我们查看下那些类都使用了AQS，见下截图。

　　

 AQS核心部分

　　1.state:实现类不同则含义不同，在Semaphore中代表剩余的许可证的数量；在CountDownLatch代表还需要倒数的数量

　　　　相关的方法如下：

　　　　

 

 

 

　　2.控制线程配合和抢锁的FIFO队列

　　　　此队列用来存放等待线程的队列，双向的链表

　　3.获取或者释放的重要方法

　　　　不同的实现类对应的获取和实现方法都不相同。

　　AQS用法

　　　　我们从CountDownLath、Semaphore、ReentrantLock中分析AQS的用法

　　　　CountDownLath中AQS用法

　　　　　　我们从构造、计数、countDown和await进行分析，首先我们看下构造：构造时，我们需要复制sycn，我们将count设置成了state

　　　　　　

　　　　　　

 

 

 

 

 

 　　　　     我们在分析类的继承关系：

　　　　　　    

 

 

 　　　　　　　接下来我们查看下await方法，如下所示：

　　　　　　　　

 

　　　　　　　　

 

 

 

 　　　　　　　　　

 

 

                           

 private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        if (nanosTimeout <= 0L)
            return false;
        final long deadline = System.nanoTime() + nanosTimeout;
        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 true;
                    }
                }
                nanosTimeout = deadline - System.nanoTime();
                if (nanosTimeout <= 0L)
                    return false;
                if (shouldParkAfterFailedAcquire(p, node) &&
                    nanosTimeout > spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout);
                if (Thread.interrupted())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

　　

 

　　　　Semaphore中AQS用法

　　　　　　我们重点分析下信号量中是如何获取的，即require方法的实现。

　　　　　　

 

 

final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }

　　　　　　上述代码是非公平时，获取信号量的方法，从代码中我可以看到使用了CAS的自旋操作，首先我们获取目前系统中剩余的信号量即为availabe;减去需要申请的信号量，

　　　　　　remaining代表剩余的信号量，当剩余信号量为负数时，说明此时申请失败，继续下一次的循环，当剩余信号量remaining大于等于0时，说明可以申请了，

                     继续执行CAS

　　　　　　操作修改state值，若修改成功，则获取成功；若修改失败，则代表被其他线程抢走了，继续执行循环直到申请到为止。

　　　　ReentrantLock中AQS用法

　　　　　　我们熟知ReenTrantLock是一把可重入锁，本实例我们从非公平的情况下进行分析，首先我看ReenTrantLock内部类的结构或者相关的方法。如下图所示：

　　　　　　

 

 　　　　　　　　接下来我们分析非公平的加锁的实现。

　　　　　　　　

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

　　      从代码结构中可以看到：首先我们执行CAS的加锁操作，将state=0 修改成state=1;

　　　　　　　　　　　　　　 若修改成功，则标记当前线程为锁的持有者；

　　　　　　　　　　　　　　 若修改失败，则我们基于执行acquire方法，

　　　　接下来我们分析acquire方法的实现：

　　　　

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

　　　　　　下面代码为tryAcquire的实现。

　　　　　　我们可以看到：首先我获取state的值，如果state=0;说明锁没有被占用，然后CAS操作，设置当前线程持有锁；

　　　　　　　　　　　　　　　　　　　　　　　如果state不等于0，判断是不是持有者，如果是，则进行重入操作，state+1;

　　　　　　　

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

　　        下面代码为释放锁的代码实现，如下图：

　　　　

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

　　　　　　我们发现释放锁的时候，需要判断当前线程是不是持有锁，否则会抛出异常；若c=0，则直接释放；否则重入次数减去1