Java多线程深入学习-AbstractQueuedSynchronizer框架源码解析

AbstractQueuedSynchronizer

    AbstractQueuedSynchronizer为实现依赖于先进先出 (FIFO) 等待队列的阻塞锁定和相关同步器（信号量、事件，等等）提供一个框架。此类的设计目标是成为依靠单个原子 int 值来表示状态的大多数同步器的一个有用基础。子类必须定义更改此状态的受保护方法，并定义哪种状态对于此对象意味着被获取或被释放。假定这些条件之后，此类中的其他方法就可以实现所有排队和阻塞机制。但只是为了获得同步而只追踪使用 getState()、setState(int) 和 compareAndSetState(int, int) 方法来操作以原子方式更新的 int 值。

1.锁持有者管理AbstractOwnableSynchronizer

/**
 * 锁持有者管理器 抽象类 -- 设置 和 获取独占锁的拥有者线程
 */
public abstract class AbstractOwnableSynchronizer implements java.io.Serializable {

    private static final long serialVersionUID = 3737899427754241961L;

    protected AbstractOwnableSynchronizer() { }

    /** 锁持有者的线程 */
    private transient Thread exclusiveOwnerThread;

    /**
     * 设置锁持有者的线程
     * @param thread
     */
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }
    /**
     * 获取锁持有者的线程
     */
    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
}

2.阻塞队列里的节点定义AbstractQueuedSynchronizer.Node

    /** 阻塞队列里的节点定义 */
    static final class Node {
        static final Node SHARED = new Node();	//共享状态
        static final Node EXCLUSIVE = null;		//互斥状态
        static final int CANCELLED =  1;		//值为1，被取消的，在等待队列中等待的线程超时或被中断，进入该状态的节点的将不再变化
        static final int SIGNAL    = -1;		//值为-1，当前节点在入队后、进入休眠状态前，应确保将其prev节点类型改为SIGNAL，以便后者取消或释放时将当前节点唤醒
        static final int CONDITION = -2;		//值为-2，该节点处于条件队列中，当其他线程调用了Condition的signal()方法后，节点转移到AQS的等待队列中，特别要注意的是，条件队列和AQS的等待队列并不是一回事
        static final int PROPAGATE = -3;		//WaistStand值指示下一个获取应该无条件传播
        /** WaistStand值为0这里没写，为0也算是一种状态，但不是上面所有的,表示没有被任何锁拥有 */
        volatile int waitStatus;	//等待状态
        volatile Node prev;			//前一个node
        volatile Node next;			//后一个node
        volatile Thread thread;		//在node里面的线程
        Node nextWaiter;			//下一个正处在等待条件的node
        /**如果在等待node在共享模式下返回true*/
        final boolean isShared() {
            return nextWaiter == SHARED;
        }
        /**返回前一个node。如果为空返回空指针异常*/
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }
        /** 用于建立初始标记或共享标记 */
        Node() {
        }
        /** 给线程添加等待模型，生成node */
        Node(Thread thread, Node mode) {
            this.nextWaiter = mode;
            this.thread = thread;
        }
        /** 给线程添加等待条件，生成node */
        Node(Thread thread, int waitStatus) {
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

3.CAS实现

    /** 
     * 引入unsafe类 
     * 	通过unsafe.objectFieldOffset获取字段对应的偏移量
     */
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long stateOffset;
    private static final long headOffset;
    private static final long tailOffset;
    private static final long waitStatusOffset;
    private static final long nextOffset;
    static {
        try {
        	/**
        	 * class.getDeclaredField(String fieldName)  获取class中fieldName对应的字段
        	 * unsafe.objectFieldOffset(Field field)	获取字段field在类中对应的地址偏移量
        	 */
            stateOffset = unsafe.objectFieldOffset
                (AbstractQueuedSynchronizer.class.getDeclaredField("state"));	//同步的状态
            headOffset = unsafe.objectFieldOffset
                (AbstractQueuedSynchronizer.class.getDeclaredField("head"));	//等待队列头节点
            tailOffset = unsafe.objectFieldOffset
                (AbstractQueuedSynchronizer.class.getDeclaredField("tail"));	//等待队列尾节点
            waitStatusOffset = unsafe.objectFieldOffset
                (Node.class.getDeclaredField("waitStatus"));
            nextOffset = unsafe.objectFieldOffset
                (Node.class.getDeclaredField("next"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    /** 用到CAS进行原子更新。如果当前状态值等于预期值，则以原子方式将同步状态设置为给定的更新值。 */
    private final boolean compareAndSetHead(Node update) {	//设置state  null -- update
        return unsafe.compareAndSwapObject(this, headOffset, null, update);
    }
    private final boolean compareAndSetTail(Node expect, Node update) { //设置tail  expect -- update
        return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
    }
    private static final boolean compareAndSetWaitStatus(Node node, int expect, int update) {//设置