java高并发、多线程（五）--AbstractQueuedSynchronizer

AbstractQueuedSynchronizer

AbstractQueuedSynchronizer（AQS）提供一个框架，用于实现依赖先进先出（FIFO）等待队列的阻塞锁和相关同步器（信号量，事件等）。
首先我们来看看它的源码结构：

public abstract class AbstractQueuedSynchronizer
        extends AbstractOwnableSynchronizer
        implements java.io.Serializable {

    private static final long serialVersionUID = 7373984972572414691L;
    protected AbstractQueuedSynchronizer() { }

    /**
     * 队列节点.
     */
    static final class Node { /*...*/}
	//队列头节点
    private transient volatile Node head;
    //队列尾节点
    private transient volatile Node tail;
    //同步状态，等于0时表示无锁，大于0表示有锁
    private volatile int state;
}

再看看内部类Node的结构：该类利用双向链表结构实现了同步器队列，condition利用单向链表结构实现condition队列

static final class Node {
        static final Node SHARED = new Node();
        static final Node EXCLUSIVE = null;
        /**
         * 等待状态:SIGNAL、CANCELLED、CONDITION、PROPAGATE、0
         */
        volatile int waitStatus;
        //同步器队列前驱节点
        volatile Node prev;
        //同步器队列后继节点
        volatile Node next;
        volatile Thread thread;
        //condition队列后继节点
        Node nextWaiter;
    }

接着我们再来看看它的几个重要方法：

• getState()
  返回同步状态的当前值。 这个操作具有一个volatile读取的记忆语义。

	protected final int getState() {
        return state;
    }

• setState(int)
  设置同步状态的值。 这个操作有一个volatile写的内存语义。

	protected final void setState(int newState) {
        state = newState;
    }

• compareAndSetState(int，int)
  如果当前状态值等于期望值，则将同步状态原子地设置为给定的更新值。 此操作具有volatile读写的记忆语义。从源码中我们也可以看出该操作主要利用的CAS实现。

	protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

• tryAcquire(int)
  以独占模式获取锁，待子类具体实现

	protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

• tryRelease(int)
  以独占模式释放锁，待子类具体实现

protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }

• tryAcquireShared(int)
  以共享模式获取锁，待子类具体实现

	protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }

• tryReleaseShared(int)
  以共享模式释放锁，待子类具体实现

protected boolean tryReleaseShared(int arg) {
        throw new UnsupportedOperationException();
    }

• isHeldExclusively()
  如果同步是以独占方式进行的，则返回true；其他情况则返回 false;待子类具体实现

	protected boolean isHeldExclusively() {
        throw new UnsupportedOperationException();
    }

余下的acquire(int arg)、tryAcquireNanos(int arg, long nanosTimeout)、release(int arg)、acquireShared(int arg)、tryAcquireSharedNanos(int arg, long nanosTimeout)、**releaseShared(int arg)**等方法我们在后面具体介绍AQS子类的时候再来介绍。现在我们仅需要明白AQS提供了一个去实现锁或者同步器的框架，它主要依赖于其同步状态属性state以及CAS来实现，其性能优于synchronized。既可以实现独占锁，也可以实现共享锁。