线程池ThreadPoolExecutor源码分析一(AbstractQueuedSynchronizer)

一个重要的抽象类，提供了一个实现阻塞锁以及依赖于先进先出队列的同步器的相关操作。

常用的ReentrantLock、ReentrantReadWriteLock以及同步相关的类，都依赖于该类的框架，他们的组成结构都是通过内部类继承该类来实现相应功能。

这个类本身继承了AbstractOwnableSychronizer类，对于AbstractOwnableSychronizer抽象类而言，仅仅只有一个Thread类的成员变量，以及该变量的setter和getter方法，作用就是保存标记该类独享的线程。

回到AbstractQueuedSynchronizer类本身，这个类的组成较为复杂，在这里，仅仅分析该类的部分变量，不讨论该类实现的方法，方法讨论会在分析ReentrantLock等类时同时贴出。

一、内部类

1.1 Node静态内部类

        用来保存节点信息，同样的，暂时只需要记住该类的一些变量

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; // 等待，配合Condition接口子类使用
    static final int PROPAGATE = -3; // 
    volatile int waitStatus; // 等待状态值，上面4种状态加上初始化的0状态
    volatile Node prev; // 保存前一个节点的引用
    volatile Node next; // 保存下一个节点的引用
    volatile Thread thread; // 该节点所在线程
    Node nextWaiter; // 下一个等待节点引用
}

1.2 ConditionObject内部类

public class ConditionObject {
    private static final long serialVersionUID = 1173984872572414699L;
    //第一个等待节点引用
    private transient Node firstWaiter;
    //最后一个等待节点引用
    private transient Node lastWaiter;
    public ConditionObject() { }
}

1.3 其他变量

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

    static final class Node {
    }
    class ConditionObject {
    }
    
    // 头部节点
    private transient volatile Node head;
    // 尾部节点
    private transient volatile Node tail;
    // 同步状态
    private volatile int state;
    
    /*下面是关于原子操作实现相关类，每次改变state、node节点值都会通过该类进行原子操作，stateOffset表示state变量的偏移量*/
    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 {
            stateOffset = unsafe.objectFieldOffset
                    (java.util.concurrent.locks.AbstractQueuedSynchronizer.class.getDeclaredField("state"));
            headOffset = unsafe.objectFieldOffset
                    (java.util.concurrent.locks.AbstractQueuedSynchronizer.class.getDeclaredField("head"));
            tailOffset = unsafe.objectFieldOffset
                    (java.util.concurrent.locks.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); }
    }
}

上面就是AbstractQueuedSynchronizer类主要的变量，其中Node节点可以理解为每一个调用该AbstractQueuedSynchronizer子类实例的线程，ConditionObject实现了Condition接口，当调用ReentrantLock.newCondition()方法，其实就是在实例化ConditionObject，后续的操作都依赖ConditionObject的方法的实现。

其中AbstractQueuedSynchronizer抽象类提供了很多抽象方法，需要子类提供具体实现，比如平常使用到的lock方法内，tryAcqueire(int x)就需要子类提供实现，以及unlock里面的tryRelease()同样。

了解该类主要是为了后续分析ReentrantLock等实现类提供清晰的思路，因为在分析子类的具体实现时，方法以及变量可能会在类之间相互切换着看，大致了解了该类方便后续的分析。