同步器AQS解析

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);
    }
    // 其他方法...
}