AbstractQueuedSynchronizer 源码理解
UnSafe类（原子操作）：
/**
* 比较obj的offset处内存位置中的值和期望的值，如果相同则更新。此更新是不可中断的。
*
* @param obj 需要更新的对象
* @param offset obj中整型field的偏移量
* @param expect 希望field中存在的值
* @param update 如果期望值expect与field的当前值相同，设置filed的值为这个新值
* @return 如果field的值被更改返回true
*/
public native boolean compareAndSwapInt(Object obj, long offset, int expect, int update);
AbstractQueuedSynchronizer类：
* <p>To enqueue into a CLH lock, you atomically splice it in as new
* tail. To dequeue, you just set the head field.
*
<pre>
* +
------
+ prev +
-----
+ +
-----
+
* head | | <---- | | <---- | | tail
* +
------
+ +
-----
+ +
-----
+
*
</pre>
/**
* Inserts node into queue, initializing if necessary. See picture above.
*
@param
node the node to insert
*
@return
node's predecessor
*/
private
Node enq(
final
Node node) {
for
(;;) {
Node t =
tail
;
if
(t ==
null
) {
// Must initialize
//如果头部为空，则更新，并赋值给tail
if
(compareAndSetHead(
new
Node()))
tail
=
head
;
}
else
{
//
让tail指向新插入的结点
node.
prev
= t;
if
(compareAndSetTail(t, node)) {
t.
next
= node;
return
t;
}
}
}
}
/**
* Creates and enqueues node for current thread and given mode.
*
*
@param
mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared 标明是否共享：
addWaiter(Node.
EXCLUSIVE
) null
addWaiter(Node.
SHARED
); new Node();
*
@return
the new node
*/
private
Node addWaiter(Node mode) {
Node node =
new
Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred =
tail
;
if
(pred !=
null
) {
node.
prev
= pred;
if
(compareAndSetTail(pred, node)) {
pred.
next
= node;
return
node;
}
}
enq(node);
return
node;
}