AQS注释源码

╰+哭是因爲堅強的太久メ 2022-02-26 03:29 279阅读 0赞

**注释的AQS的源码：如下：**

public class AbstractQueuedSynchronizerTest {
 static final class Node {
 
 /** Marker to indicate a node is waiting in shared mode */
 static final Node SHARED = new Node();
 /** Marker to indicate a node is waiting in exclusive mode 
 * 
 * */
 static final Node EXCLUSIVE = null;
 
 /** waitStatus value to indicate thread has cancelled 
 * 在同步队列中等待的线程等待超时或者被中断，需要从同步队列中取消等待
 * */
 static final int CANCELLED = 1;
 
 /** waitStatus value to indicate successor's thread needs unparking(唤醒)
 * 后继节点的线程处于等待状态，而当前的节点如果释放了同步状态或者被取消，将会通知后继节点，使后继节点的线程得以运行。
 **/
 static final int SIGNAL = -1;
 
 /** waitStatus value to indicate thread is waiting on condition 
 * 节点在等待队列中，节点的线程等待在Condition上，当其他线程对Condition调用了signal()方法后，该节点会从等待队列中转移到同步队列中，加入到同步状态的获取中
 **/
 static final int CONDITION = -2;
 /**
 * waitStatus value to indicate the next acquireShared should
 * unconditionally（无条件的） propagate（传播）
 * 
 * 表示下一次共享式同步状态获取将会被无条件地传播下去
 */
 static final int PROPAGATE = -3;
 
 /**
 * Status field, taking on only the values:
 * SIGNAL: The successor of this node is (or will soon be)
 * blocked (via park), so the current node must
 * unpark its successor when it releases or
 * cancels. To avoid races, acquire methods must
 * first indicate they need a signal,
 * then retry the atomic acquire, and then,
 * on failure, block.
 * CANCELLED: This node is cancelled due to timeout or interrupt.
 * Nodes never leave this state. In particular,
 * a thread with cancelled node never again blocks.
 * CONDITION: This node is currently on a condition queue.
 * It will not be used as a sync queue node
 * until transferred, at which time the status
 * will be set to 0. (Use of this value here has
 * nothing to do with the other uses of the
 * field, but simplifies mechanics.)
 * PROPAGATE: A releaseShared should be propagated（传播） to other
 * nodes. This is set (for head node only) in
 * doReleaseShared to ensure propagation
 * continues, even if other operations have
 * since intervened（干涉）.
 * 0: None of the above
 *
 * The values are arranged numerically to simplify use.
 * Non-negative values mean that a node doesn't need to
 * signal. So, most code doesn't need to check for particular
 * values, just for sign.
 *
 * The field is initialized to 0 for normal sync nodes, and
 * CONDITION for condition nodes. It is modified using CAS
 * (or when possible, unconditional volatile writes).
 * 
 * 使用CAS更改状态，volatile保证线程可见性，即被一个线程修改后，状态会立马让其他线程可见。
 * 
 */
 volatile int waitStatus;
 
 /**
 * Link to predecessor node that current node/thread relies on
 * for checking waitStatus. Assigned during enqueing（入队）, and nulled
 * out (for sake of GC) only upon dequeuing. Also, upon
 * cancellation of a predecessor, we short-circuit while
 * finding a non-cancelled one, which will always exist
 * because the head node is never cancelled: A node becomes
 * head only as a result of successful acquire. A
 * cancelled thread never succeeds in acquiring, and a thread only
 * cancels itself, not any other node.
 * 
 * 前驱节点，当前节点加入到同步队列中被设置
 */
 volatile Node prev;
 
 /**
 * Link to the successor node that the current node/thread
 * unparks upon release. Assigned during enqueuing, adjusted
 * when bypassing cancelled predecessors, and nulled out (for
 * sake of GC) when dequeued. The enq operation does not
 * assign next field of a predecessor until after attachment,
 * so seeing a null next field does not necessarily mean that
 * node is at end of queue. However, if a next field appears
 * to be null, we can scan prev's from the tail to
 * double-check. The next field of cancelled nodes is set to
 * point to the node itself instead of null, to make life
 * easier for isOnSyncQueue.
 * 
 * 后继节点
 */
 volatile Node next;
 
 /**
 * The thread that enqueued this node. Initialized on
 * construction and nulled out after use.
 * 
 * 获取同步状态的线程
 */
 volatile Thread thread;
 
 /**
 * Link to next node waiting on condition, or the special
 * value SHARED. Because condition queues are accessed only
 * when holding in exclusive(独有的) mode, we just need a simple
 * linked queue to hold nodes while they are waiting on
 * conditions. They are then transferred（移动到） to the queue（同步队列） to
 * re-acquire. And because conditions can only be exclusive,
 * we save a field by using special value to indicate shared
 * mode.
 * 
 * 等待队列中的后继节点，如果当前节点是共享的，那么这个字段是一个SHARED常量，
 * 也就是说节点类型(独占和共享)和等待队列中的后继节点共用同一个字段。
 */
 Node nextWaiter;
 
 /**
 * Returns true if node is waiting in shared mode
 */
 final boolean isShared() {
 return nextWaiter == SHARED;
 }
 
 /**
 * Returns previous node, or throws NullPointerException if null.
 * Use when predecessor cannot be null. The null check could
 * be elided, but is present to help the VM.
 *
 * @return the predecessor of this node
 */
 final Node predecessor() throws NullPointerException {
 Node p = prev;
 if (p == null)
 throw new NullPointerException();
 else
 return p;
 }
 
 Node() { // Used to establish initial head or SHARED marker
 }
 
 Node(Thread thread, Node mode) { // Used by addWaiter
 this.nextWaiter = mode;
 this.thread = thread;
 }
 
 Node(Thread thread, int waitStatus) { // Used by Condition
 this.waitStatus = waitStatus;
 this.thread = thread;
 }
 }
 
 /**
 * Head of the wait queue, lazily initialized. Except for (除...以外)
 * initialization（初始化）, it is modified only via method setHead. Note:
 * If head exists, its waitStatus is guaranteed not to be
 * CANCELLED.（如果head引用已经存在，等待状态保证不会被取消）
 */
 private transient volatile Node head;
 
 /**
 * Tail of the wait queue（等待队列）, lazily initialized. Modified only via
 * method enq to add new wait node.
 */
 private transient volatile Node tail;
 
 /**
 * The synchronization state.
 * 同步状态，线程可见的，共享内存里面保存
 * 
 */
 private volatile int state;
 
 /**
 * Returns the current value of synchronization state.
 * This operation has memory semantics of a <tt>volatile</tt> read.
 * @return current state value
 * 
 * 得到同步状态的值
 * 
 */
 protected final int getState() {
 return state;
 }
 
 /**
 * Sets the value of synchronization state.
 * This operation has memory semantics of a <tt>volatile</tt> write.
 * @param newState the new state value
 */
 protected final void setState(int newState) {
 state = newState;
 }
 
 /**
 * Acquires in exclusive(互斥) mode, ignoring（忽视） interrupts. Implemented
 * by invoking at least once {@link #tryAcquire},
 * returning on success. Otherwise the thread is queued（排队）, possibly
 * repeatedly（反复的） blocking and unblocking, invoking {@link
 * #tryAcquire} until success. This method can be used
 * to implement method {@link Lock#lock}.
 *
 * @param arg the acquire argument. This value is conveyed（传达） to
 * {@link #tryAcquire} but is otherwise uninterpreted and
 * can represent anything you like.
 * 
 * 独占式的获取同步状态 
 * 
 */
 public final void acquire(int arg) {
 if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
 selfInterrupt();
 }
 
 protected boolean tryAcquire(int arg) {
 throw new UnsupportedOperationException();
 }
 
 /**
 * Creates and enqueues node for current thread and given mode.
 *
 * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
 * @return the new node
 * 
 * 
 * 如果尝试获取同步状态失败的话,则构造同步节点（独占式的Node.EXCLUSIVE），通过 addWaiter(Node node,int args)方法将该节点加入到同步队列的队尾。
 
 * 
 */
 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;
 }
 
 /**
 * Convenience method to interrupt current thread.
 * 分析：如果在acquireQueued()中，当前线程被中断过，则执行selfInterrupt()；否则不会执行。
 * 线程在阻塞状态被“中断唤醒”而获取CPU的执行权；但是该线程前面还有其他等待锁的线程，根据公平性原则，该线程仍然无法获取到锁，他会再次阻塞。
 * 直到该线程被他前面等待锁的线程唤醒；线程才会获取锁。该线程“成功获取锁并真正执行起来之前”，他的中断会被忽略并且中断标记会被清除，因为在parkAndCheckInterrupt()中，
 * 我们线程的中断状态时调用了Thread.interrupted()，这个函数在返回中断状态之后，还会清除中断状态，正因为清除了中断状态，所以在selfInterrupt重新产生一个中断。
 * 
 * 
 * 当前线程自己产生一个中断
 */
 private static void selfInterrupt() {
 Thread.currentThread().interrupt();
 }
 
 /**
 * Acquires in exclusive uninterruptible mode for thread already in
 * queue. Used by condition wait methods as well as acquire.
 *
 * @param node the node
 * @param arg the acquire argument
 * @return {@code true} if interrupted while waiting
 * 
 * acquireQueued方法当前线程在死循环中获取同步状态，而只有前驱节点是头节点才能尝试获取同步状态（ p == head && tryAcquire(arg)）
 * 原因是:1.头结点是成功获取同步状态的节点，而头节点的线程释放了同步状态以后，将会唤醒其后继节点，后继节点的线程被唤醒后要检查自己的前驱节点是否为头结点。
 * 2.维护同步队列的FIFO原则，节点进入同步队列之后，就进入了一个自旋的过程，每个节点（或者说是每个线程）都在自省的观察。
 * 
 */
 final boolean acquireQueued(final Node node, int arg) {
 boolean failed = true;
 try {
 boolean interrupted = false;
 for (;;) {
 final Node p = node.predecessor();
 if (p == head && tryAcquire(arg)) {
 setHead(node);
 p.next = null; // help GC
 failed = false;
 return interrupted;
 }
 if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
 interrupted = true;
 }
 } finally {
 if (failed)
 cancelAcquire(node);
 }
 }
 
 /**
 * Inserts node into queue, initializing if necessary. See picture above.
 * @param node the node to insert
 * @return node's predecessor
 * 
 * 同步器通过死循环的方式来保证节点的正确添加，在“死循环” 中通过CAS将节点设置成为尾节点之后，当前线程才能从该方法中返回，否则当前线程不断的尝试设置。
 * enq方法将并发添加节点的请求通过CAS变得“串行化”了。
 * 
 */
 private Node enq(final Node node) {
 for (;;) {
 Node t = tail;
 if (t == null) { // Must initialize
 if (compareAndSetHead(new Node()))
 tail = head;
 } else {
 node.prev = t;
 if (compareAndSetTail(t, node)) {
 t.next = node;
 return t;
 }
 }
 }
 }
 
 /**
 * Convenience method to park and then check if interrupted
 *
 * @return {@code true} if interrupted
 * 
 * 阻塞当前线程
 * 
 */
 private final boolean parkAndCheckInterrupt() {
 // 阻塞当前线程
 LockSupport.park(this);
 // 线程被唤醒之后的中断状态
 return Thread.interrupted();
 }
 
 /**
 * Releases in exclusive mode. Implemented by unblocking one or
 * more threads if {@link #tryRelease} returns true.
 * This method can be used to implement method {@link Lock#unlock}.
 *
 * @param arg the release argument. This value is conveyed to
 * {@link #tryRelease} but is otherwise uninterpreted and
 * can represent anything you like.
 * @return the value returned from {@link #tryRelease}
 * 
 * 释放公平锁
 * 
 */
 public final boolean release(int arg) {
 if (tryRelease(arg)) {
 Node h = head;
 if (h != null && h.waitStatus != 0)
 unparkSuccessor(h);
 return true;
 }
 return false;
 }
 
 /**
 * Attempts to set the state to reflect a release in exclusive
 * mode.
 *
 * This method is always invoked by the thread performing release.
 *
 * The default implementation throws
 * {@link UnsupportedOperationException}.
 *
 * @param arg the release argument. This value is always the one
 * passed to a release method, or the current state value upon
 * entry to a condition wait. The value is otherwise
 * uninterpreted and can represent anything you like.
 * @return {@code true} if this object is now in a fully released
 * state, so that any waiting threads may attempt to acquire;
 * and {@code false} otherwise.
 * @throws IllegalMonitorStateException if releasing would place this
 * synchronizer in an illegal state. This exception must be
 * thrown in a consistent fashion for synchronization to work
 * correctly.
 * @throws UnsupportedOperationException if exclusive mode is not supported
 */
 protected boolean tryRelease(int arg) {
 throw new UnsupportedOperationException();
 }
 
 /**
 * Checks and updates status for a node that failed to acquire.
 * Returns true if thread should block. This is the main signal
 * control in all acquire loops. Requires that pred == node.prev
 *
 * @param pred node's predecessor holding status
 * @param node the node
 * @return {@code true} if thread should block
 * 返回当前线程是否应该阻塞
 * 
 * 说明：
 (01) 关于waitStatus请参考下表(中扩号内为waitStatus的值)，更多关于waitStatus的内容，可以参考前面的Node类的介绍。
 
 CANCELLED[1] -- 当前线程已被取消
 SIGNAL[-1] -- “当前线程的后继线程需要被unpark(唤醒)”。一般发生情况是：当前线程的后继线程处于阻塞状态，而当前线程被release或cancel掉，因此需要唤醒当前线程的后继线程。
 CONDITION[-2] -- 当前线程(处在Condition休眠状态)在等待Condition唤醒
 PROPAGATE[-3] -- (共享锁)其它线程获取到“共享锁”
 [0] -- 当前线程不属于上面的任何一种状态。
 (02) shouldParkAfterFailedAcquire()通过以下规则，判断“当前线程”是否需要被阻塞。
 
 规则1：如果前继节点状态为SIGNAL，表明当前节点需要被unpark(唤醒)，此时则返回true。
 规则2：如果前继节点状态为CANCELLED(ws>0)，说明前继节点已经被取消，则通过先前回溯找到一个有效(非CANCELLED状态)的节点，并返回false。
 规则3：如果前继节点状态为非SIGNAL、非CANCELLED，则设置前继的状态为SIGNAL，并返回false。
 * 
 */
 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
 // 前驱节点的状态
 int ws = pred.waitStatus;
 // 如果前驱节点是SIGNAL状态，则意味着当前线程需要unpark唤醒，此时返回true
 if (ws == Node.SIGNAL)
 /*
 * This node has already set status asking a release to signal it, so it can safely park.
 */
 return true;
 // 如果前继节点是取消的状态，则设置当前节点的“当前前继节点为”原节点的前继节点
 if (ws > 0) {
 /*
 * Predecessor was cancelled. Skip over predecessors and indicate retry.
 */
 do {
 node.prev = pred = pred.prev;
 } while (pred.waitStatus > 0);
 pred.next = node;
 } else {
 /*
 * waitStatus must be 0 or PROPAGATE. Indicate that we need a signal, but don't park yet. Caller will need to retry to make sure
 * it cannot acquire before parking.
 */
 compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
 }
 return false;
 }
 
 /**
 * Cancels an ongoing attempt to acquire.
 *
 * @param node the node
 */
 private void cancelAcquire(Node node) {
 // Ignore if node doesn't exist
 if (node == null)
 return;
 
 node.thread = null;
 
 // Skip cancelled predecessors
 Node pred = node.prev;
 while (pred.waitStatus > 0)
 node.prev = pred = pred.prev;
 
 // predNext is the apparent node to unsplice. CASes below will
 // fail if not, in which case, we lost race vs another cancel
 // or signal, so no further action is necessary.
 Node predNext = pred.next;
 
 // Can use unconditional write instead of CAS here.
 // After this atomic step, other Nodes can skip past us.
 // Before, we are free of interference from other threads.
 node.waitStatus = Node.CANCELLED;
 
 // If we are the tail, remove ourselves.
 if (node == tail && compareAndSetTail(node, pred)) {
 compareAndSetNext(pred, predNext, null);
 } else {
 // If successor needs signal, try to set pred's next-link
 // so it will get one. Otherwise wake it up to propagate.
 int ws;
 if (pred != head && ((ws = pred.waitStatus) == Node.SIGNAL || (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL)))
 && pred.thread != null) {
 Node next = node.next;
 if (next != null && next.waitStatus <= 0)
 compareAndSetNext(pred, predNext, next);
 } else {
 unparkSuccessor(node);
 }
 
 node.next = node; // help GC
 }
 }
 
 /**
 * Wakes up node's successor, if one exists.
 *
 * @param node the node
 */
 private void unparkSuccessor(Node node) {
 /*
 * If status is negative (i.e., possibly needing signal) try to clear in anticipation of signalling. It is OK if this fails or if
 * status is changed by waiting thread.
 */
 int ws = node.waitStatus;
 if (ws < 0)
 compareAndSetWaitStatus(node, ws, 0);
 
 /*
 * Thread to unpark is held in successor, which is normally just the next node. But if cancelled or apparently null, traverse
 * backwards from tail to find the actual non-cancelled successor.
 */
 Node s = node.next;
 if (s == null || s.waitStatus > 0) {
 s = null;
 for (Node t = tail; t != null && t != node; t = t.prev)
 if (t.waitStatus <= 0)
 s = t;
 }
 if (s != null)
 LockSupport.unpark(s.thread);
 }
 
 /**
 * Sets head of queue to be node, thus dequeuing. Called only by
 * acquire methods. Also nulls out unused fields for sake of GC
 * and to suppress unnecessary signals and traversals.
 *
 * @param node the node
 */
 private void setHead(Node node) {
 head = node;
 node.thread = null;
 node.prev = null;
 }
 
 /**
 * Atomically sets synchronization state to the given updated
 * value if the current state value equals the expected value.
 * This operation has memory semantics of a <tt>volatile</tt> read
 * and write.
 *
 * @param expect the expected value
 * @param update the new value
 * @return true if successful. False return indicates that the actual
 * value was not equal to the expected value.
 */
 protected final boolean compareAndSetState(int expect, int update) {
 // See below for intrinsics setup to support this
 return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
 }
 
 /**
 * CAS waitStatus field of a node.
 */
 private static final boolean compareAndSetWaitStatus(Node node, int expect, int update) {
 return unsafe.compareAndSwapInt(node, waitStatusOffset, expect, update);
 }
 
 /**
 * CAS next field of a node.
 */
 private static final boolean compareAndSetNext(Node node, Node expect, Node update) {
 return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
 }
 
 /**
 * CAS tail field. Used only by enq.
 */
 private final boolean compareAndSetTail(Node expect, Node update) {
 return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
 }
 
 /**
 * CAS head field. Used only by enq.
 */
 private final boolean compareAndSetHead(Node update) {
 return unsafe.compareAndSwapObject(this, headOffset, null, update);
 }
 
 /**
 * Setup to support compareAndSet. We need to natively implement
 * this here: For the sake of permitting future enhancements, we
 * cannot explicitly subclass AtomicInteger, which would be
 * efficient and useful otherwise. So, as the lesser of evils, we
 * natively implement using hotspot intrinsics（编译器内部函数） API. And while we
 * are at it, we do the same for other CASable fields (which could
 * otherwise be done with atomic field updaters).
 */
 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(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);
 }
 }
 
 }

AbstractOwnableSynchronizer的源码如下：

package concurrentMy.aqs;
 
 /**
 * 
 * (设置和获取锁的持有者线程)
 *
 * 
 * 修改历史: 
 * 修改日期 修改人员 版本 修改内容 
 * ------------------------------------------------- 
 * 2016年7月5日 下午3:42:37 user 1.0 初始化创建 
 * 
 *
 * @author Peng.Li 
 * @version 1.0 
 * @since JDK1.7
 */
 public abstract class AbstractOwnableSynchronizerTest implements java.io.Serializable {
 
 /** Use serial ID even though all fields transient. */
 private static final long serialVersionUID = 3737899427754241961L;
 
 /**
 * Empty constructor for use by subclasses.
 */
 protected AbstractOwnableSynchronizerTest() {
 }
 
 /**
 * The current owner of exclusive mode synchronization.
 * 
 * 加 transient 表示exclusiveOwnerThread不能被串行化，不会被作为序列化的一部分
 * 
 * 锁的持有线程
 */
 private transient Thread exclusiveOwnerThread;
 
 /**
 * Sets the thread that currently owns exclusive access. A
 * <tt>null</tt> argument indicates that no thread owns access.
 * This method does not otherwise impose any synchronization or
 * <tt>volatile</tt> field accesses.
 * 
 * protected final来修饰，表示子类可以使用这个方法，但是不能重载这个方法，也就是不能修改这个方法
 */
 protected final void setExclusiveOwnerThread(Thread t) {
 exclusiveOwnerThread = t;
 }
 
 /**
 * Returns the thread last set by
 * <tt>setExclusiveOwnerThread</tt>, or <tt>null</tt> if never
 * set. This method does not otherwise impose any synchronization
 * or <tt>volatile</tt> field accesses.
 * @return the owner thread
 */
 protected final Thread getExclusiveOwnerThread() {
 return exclusiveOwnerThread;
 }
 }