保存源码注释

Author: diguage

src/jdk/java.base/java/util/concurrent/ArrayBlockingQueue.java

@@ -117,6 +117,7 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
      * found in any textbook.
      */
 
+    // 一把锁 lock，两个条件 notEmpty + notFull
     /** Main lock guarding all access */
     final ReentrantLock lock;
 
@@ -184,7 +185,7 @@ private void enqueue(E e) {
         items[putIndex] = e;
         if (++putIndex == items.length) putIndex = 0;
         count++;
-        notEmpty.signal();
+        notEmpty.signal(); // 入队成功，则通知非空条件
     }
 
     /**
@@ -203,7 +204,7 @@ private E dequeue() {
         count--;
         if (itrs != null)
             itrs.elementDequeued();
-        notFull.signal();
+        notFull.signal(); // 出队成功，则通知非满条件
         return e;
     }
 
@@ -271,6 +272,7 @@ public ArrayBlockingQueue(int capacity, boolean fair) {
         if (capacity <= 0)
             throw new IllegalArgumentException();
         this.items = new Object[capacity];
+        // 在构造函数中初始化锁和条件
         lock = new ReentrantLock(fair);
         notEmpty = lock.newCondition();
         notFull =  lock.newCondition();
@@ -367,7 +369,7 @@ public void put(E e) throws InterruptedException {
         lock.lockInterruptibly();
         try {
             while (count == items.length)
-                notFull.await();
+                notFull.await(); // 当 put 时，队列已满，阻塞在“非满”条件
             enqueue(e);
         } finally {
             lock.unlock();
@@ -417,7 +419,7 @@ public E take() throws InterruptedException {
         lock.lockInterruptibly();
         try {
             while (count == 0)
-                notEmpty.await();
+                notEmpty.await(); // take 时，如果队列为空，则阻塞在“非空”条件上
             return dequeue();
         } finally {
             lock.unlock();

src/jdk/java.base/java/util/concurrent/ConcurrentHashMap.java

@@ -2666,13 +2666,13 @@ private final void treeifyBin(Node<K,V>[] tab, int index) {
         Node<K,V> b; int n;
         if (tab != null) {
             if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
-                tryPresize(n << 1);
+                tryPresize(n << 1); // 数组长度小于阈值 64，则不做红黑树转换，直接扩容
             else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
-                synchronized (b) {
+                synchronized (b) { // 链表转换成红黑树
                     if (tabAt(tab, index) == b) {
                         TreeNode<K,V> hd = null, tl = null;
                         for (Node<K,V> e = b; e != null; e = e.next) {
-                            TreeNode<K,V> p =
+                            TreeNode<K,V> p = // 遍历链表，构建红黑树
                                 new TreeNode<K,V>(e.hash, e.key, e.val,
                                                   null, null);
                             if ((p.prev = tl) == null)

src/jdk/java.base/java/util/concurrent/CyclicBarrier.java

@@ -209,36 +209,36 @@ private int dowait(boolean timed, long nanos)
             if (g.broken)
                 throw new BrokenBarrierException();
 
-            if (Thread.interrupted()) {
-                breakBarrier();
+            if (Thread.interrupted()) { // 响应中断
+                breakBarrier(); // 唤醒所有阻塞的线程
                 throw new InterruptedException();
             }
 
-            int index = --count;
-            if (index == 0) {  // tripped
+            int index = --count; // 线程每次调用 await 时，count 都减一
+            if (index == 0) {  // tripped // count == 0，则唤醒所有等待线程
                 Runnable command = barrierCommand;
                 if (command != null) {
                     try {
-                        command.run();
+                        command.run(); // 执行回调
                     } catch (Throwable ex) {
-                        breakBarrier();
+                        breakBarrier(); // 唤醒所有阻塞的线程
                         throw ex;
                     }
                 }
-                nextGeneration();
+                nextGeneration(); // 唤醒所有线程，然后把 count 复原，进入下一个迭代。
                 return 0;
             }
 
             // loop until tripped, broken, interrupted, or timed out
-            for (;;) {
+            for (;;) { // count > 0，说明没有到齐，则阻塞自己
                 try {
                     if (!timed)
                         trip.await();
                     else if (nanos > 0L)
                         nanos = trip.awaitNanos(nanos);
                 } catch (InterruptedException ie) {
                     if (g == generation && ! g.broken) {
-                        breakBarrier();
+                        breakBarrier(); // 唤醒所有阻塞的线程
                         throw ie;
                     } else {
                         // We're about to finish waiting even if we had not
@@ -251,11 +251,11 @@ else if (nanos > 0L)
                 if (g.broken)
                     throw new BrokenBarrierException();
 
-                if (g != generation)
+                if (g != generation) // 从阻塞中唤醒，返回
                     return index;
 
                 if (timed && nanos <= 0L) {
-                    breakBarrier();
+                    breakBarrier(); // 唤醒所有阻塞的线程
                     throw new TimeoutException();
                 }
             }

src/jdk/java.base/java/util/concurrent/Phaser.java

@@ -830,7 +830,7 @@ public void forceTermination() {
      * @return the phase number, or a negative value if terminated
      */
     public final int getPhase() {
-        return (int)(root.state >>> PHASE_SHIFT);
+        return (int)(root.state >>> PHASE_SHIFT); // 获取当前轮数
     }
 
     /**

src/jdk/java.base/java/util/concurrent/ScheduledThreadPoolExecutor.java

@@ -225,9 +225,9 @@ private class ScheduledFutureTask<V>
         ScheduledFutureTask(Runnable r, V result, long triggerTime,
                             long period, long sequenceNumber) {
             super(r, result);
-            this.time = triggerTime;
-            this.period = period;
-            this.sequenceNumber = sequenceNumber;
+            this.time = triggerTime; // 延迟时间
+            this.period = period; // 周期
+            this.sequenceNumber = sequenceNumber; // 序列号
         }
 
         /**
@@ -255,7 +255,7 @@ public int compareTo(Delayed other) {
                     return -1;
                 else if (diff > 0)
                     return 1;
-                else if (sequenceNumber < x.sequenceNumber)
+                else if (sequenceNumber < x.sequenceNumber) // 如果延迟时间相等，则再进一步比较序号
                     return -1;
                 else
                     return 1;
@@ -275,12 +275,15 @@ public boolean isPeriodic() {
 
         /**
          * Sets the next time to run for a periodic task.
+         * 设置下次执行时间
          */
         private void setNextRunTime() {
             long p = period;
             if (p > 0)
+                // AtFixedRate 时，p > 0，下次执行时间是上次任务开始时间 + period，即固定周期
                 time += p;
             else
+                // WithFixedDelay 时，p < 0，下次执行时间是上次任务结束时间 + period，即固定延迟
                 time = triggerTime(-p);
         }
 
@@ -300,10 +303,11 @@ public boolean cancel(boolean mayInterruptIfRunning) {
         public void run() {
             if (!canRunInCurrentRunState(this))
                 cancel(false);
-            else if (!isPeriodic())
+            else if (!isPeriodic()) // 不是周期性的，则执行一次就结束
                 super.run();
             else if (super.runAndReset()) {
-                setNextRunTime();
+                // 周期性的任务，执行完之后，重新计算延迟时间，然后再仍会队列
+                setNextRunTime(); // 设置下次执行时间
                 reExecutePeriodic(outerTask);
             }
         }
@@ -339,7 +343,7 @@ private void delayedExecute(RunnableScheduledFuture<?> task) {
         if (isShutdown())
             reject(task);
         else {
-            super.getQueue().add(task);
+            super.getQueue().add(task); // 将 ScheduledFutureTask 对象添加到等待队列
             if (!canRunInCurrentRunState(task) && remove(task))
                 task.cancel(false);
             else
@@ -625,7 +629,7 @@ public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
             new ScheduledFutureTask<Void>(command,
                                           null,
                                           triggerTime(initialDelay, unit),
-                                          unit.toNanos(period),
+                                          unit.toNanos(period), // 注意：正数
                                           sequencer.getAndIncrement());
         RunnableScheduledFuture<Void> t = decorateTask(command, sft);
         sft.outerTask = t;
@@ -673,7 +677,7 @@ public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
             new ScheduledFutureTask<Void>(command,
                                           null,
                                           triggerTime(initialDelay, unit),
-                                          -unit.toNanos(delay),
+                                          -unit.toNanos(delay), // 注意：负数
                                           sequencer.getAndIncrement());
         RunnableScheduledFuture<Void> t = decorateTask(command, sft);
         sft.outerTask = t;