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) {//设置