同步器AQS解析

什么是同步器？

　　多线程并发执行，通过某种共享状态来同步，当共享状态满足某种条件，才能触发线程开始执行操作。

AbstractQueuedSynchronizer（AQS）

　　这是一个抽象类，它提供多线程下不同共享模式的操作，实现它可以自定义同步器。

可以看出，ReentrantLock和ReentrantReadWriteLock的内部类都是继承于这个抽象类。

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

    private static final long serialVersionUID = 7270805090050340580L;
    // 底层操作
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    // 线程节点
    static final class Node {
        static final Node SHARED = new Node();
        static final Node EXCLUSIVE = null;
        static final int CANCELLED =  1;
        static final int SIGNAL    = -1;
        static final int CONDITION = -2;
        static final int PROPAGATE = -3;
        volatile int waitStatus;
        volatile Node prev;
        volatile Node next;
        volatile Thread thread;
        Node nextWaiter;

        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }

        Node() {
        }

        Node(Thread thread, Node mode) {
            this.nextWaiter = mode;
            this.thread = thread;
        }

        Node(Thread thread, int waitStatus) {
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }
    // 头结点
    private transient volatile Node head;
    // 尾节点
    private transient volatile Node tail;
    // 共享状态
    private volatile int state;
    // 独占锁获取
    protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }
    // 独占锁释放
    protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }
    // 共享锁获取
    protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }
    // 共享锁释放
    protected boolean tryReleaseShared(int arg) {
        throw new UnsupportedOperationException();
    }
    // 快速判断被线程独占
    protected boolean isHeldExclusively() {
        throw new UnsupportedOperationException();
    }
    // 获取同步状态
    protected final int getState() {
        return state;
    }
    // 设置同步状态
    protected final void setState(int newState) {
        state = newState;
    }
    // 原子操作同步状态
    protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }
    // 其他方法...
}

以上就是AQS里关键的几个需要重写的方法，这里没有将方法定义为abstract，而是方法只抛出一个异常，这是因为AQS有很多方法可以重写，而又不是每个都需要，所以就没有写成abstract。

原文地址：https://www.cnblogs.com/huanStephen/p/8228105.html