增加注释

Author: diguage

src/jdk/java.base/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java

@@ -1187,13 +1187,13 @@ private long enableWait(ConditionNode node) {
                 node.waiter = Thread.currentThread();
                 node.setStatusRelaxed(COND | WAITING);
                 ConditionNode last = lastWaiter;
-                if (last == null)
+                if (last == null) // 单链表入队
                     firstWaiter = node;
                 else
                     last.nextWaiter = node;
                 lastWaiter = node;
                 long savedState = getState();
-                if (release(savedState))
+                if (release(savedState)) // 释放锁。只有释放锁，其他的线程才能获取锁来执行程序
                     return savedState;
             }
             node.status = CANCELLED; // lock not held or inconsistent
@@ -1313,12 +1313,12 @@ else if ((node.status & COND) != 0) {
          * </ol>
          */
         public final void await() throws InterruptedException {
-            if (Thread.interrupted())
+            if (Thread.interrupted()) // 收到中断信号，抛出异常
                 throw new InterruptedException();
             ConditionNode node = newConditionNode();
             if (node == null)
                 return;
-            long savedState = enableWait(node);
+            long savedState = enableWait(node); // 建立 Condition 链表，释放锁
             LockSupport.setCurrentBlocker(this); // for back-compatibility
             boolean interrupted = false, cancelled = false, rejected = false;
             while (!canReacquire(node)) {

src/jdk/java.base/java/util/concurrent/locks/AbstractQueuedSynchronizer.java

@@ -739,7 +739,7 @@ final int acquire(Node node, int arg, boolean shared,
             } else if (pred == null) {          // try to enqueue
                 node.waiter = current;
                 node.setPrevRelaxed(t);         // avoid unnecessary fence
-                if (!casTail(t, node))
+                if (!casTail(t, node)) 入队
                     node.setPrevRelaxed(null);  // back out
                 else
                     t.next = node;

src/jdk/java.base/java/util/concurrent/locks/ReentrantLock.java

@@ -222,10 +222,11 @@ static final class NonfairSync extends Sync {
 
         final boolean initialTryLock() {
             Thread current = Thread.currentThread();
+            // 非公平锁与公平锁对比一下：非公平锁，先抢锁，不考虑排队
             if (compareAndSetState(0, 1)) { // first attempt is unguarded
                 setExclusiveOwnerThread(current); // 上来就抢，不考虑是否有排队，这是非公平锁
                 return true;
-            } else if (getExclusiveOwnerThread() == current) {
+            } else if (getExclusiveOwnerThread() == current) { // 判断是否是重入
                 int c = getState() + 1;
                 if (c < 0) // overflow
                     throw new Error("Maximum lock count exceeded");
@@ -259,6 +260,7 @@ static final class FairSync extends Sync {
         final boolean initialTryLock() {
             Thread current = Thread.currentThread();
             int c = getState();
+            // 非公平锁与公平锁对比一下：锁没有被抢，等待队列中前面没有排队节点才去抢锁
             if (c == 0) { // 锁没有被抢，且没有排队线程才去抢锁，这是公平锁。
                 if (!hasQueuedThreads() && compareAndSetState(0, 1)) {
                     setExclusiveOwnerThread(current);

src/jdk/java.base/java/util/concurrent/locks/ReentrantReadWriteLock.java

@@ -401,8 +401,10 @@ protected final boolean tryAcquire(int acquires) {
             int w = exclusiveCount(c);
             if (c != 0) {
                 // (Note: if c != 0 and w == 0 then shared count != 0)
+                // ❓w==0 为什么就有读锁？答：因为前面还有 c != 0 的条件
                 if (w == 0 || current != getExclusiveOwnerThread())
                     return false;
+                // 因为 c != 0 & w != 0，则必然是写锁持有锁
                 if (w + exclusiveCount(acquires) > MAX_COUNT)
                     throw new Error("Maximum lock count exceeded");
                 // Reentrant acquire
@@ -480,15 +482,16 @@ protected final int tryAcquireShared(int unused) {
                 getExclusiveOwnerThread() != current)
                 return -1;
             int r = sharedCount(c);
-            if (!readerShouldBlock() && // 读锁不被阻塞
+            if (!readerShouldBlock() && // 读锁不被阻塞：非公平锁是第一个节点是抢写锁的线程；公平锁，前面有排队就阻塞。
                 r < MAX_COUNT &&        // 且并发线程数少于最大阈值
-                compareAndSetState(c, c + SHARED_UNIT)) { // 抢锁成功
+                compareAndSetState(c, c + SHARED_UNIT)) { // 抢锁：高16位。JDK25中已经变成高32位了。
                 if (r == 0) { // 第一个拿到读锁的线程
                     firstReader = current;
                     firstReaderHoldCount = 1;
                 } else if (firstReader == current) {
                     firstReaderHoldCount++;
                 } else {
+                    // 统计变量，对流程没影响
                     HoldCounter rh = cachedHoldCounter;
                     if (rh == null ||
                         rh.tid != LockSupport.getThreadId(current))

src/jdk/java.base/java/util/concurrent/locks/StampedLock.java

@@ -238,7 +238,7 @@
  * @jls 17.4 Memory Model
  * @since 1.8
  * @author Doug Lea
- */
+ */ // TODO ❓读写不互斥，是不是比 ReentrantLock 更适合 BlockingQueue？
 public class StampedLock implements java.io.Serializable { // 读写也不互斥
     /*
      * Algorithmic notes: