src/java.base/share/classes/java/util/concurrent/locks/AbstractQueuedSynchronizer.java

8234131: Miscellaneous changes imported from jsr166 CVS 2021-01
Reviewed-by: martin

*** 38,47 ****
--- 38,48 ----
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Date;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.ForkJoinPool;
+ import java.util.concurrent.RejectedExecutionException;
  import jdk.internal.misc.Unsafe;
  
  /**
   * Provides a framework for implementing blocking locks and related
   * synchronizers (semaphores, events, etc) that rely on
*** 135,151 ****
   * <p>Even though this class is based on an internal FIFO queue, it
   * does not automatically enforce FIFO acquisition policies.  The core
   * of exclusive synchronization takes the form:
   *
   * <pre>
!  * Acquire:
   *     while (!tryAcquire(arg)) {
   *        <em>enqueue thread if it is not already queued</em>;
   *        <em>possibly block current thread</em>;
   *     }
   *
!  * Release:
   *     if (tryRelease(arg))
   *        <em>unblock the first queued thread</em>;
   * </pre>
   *
   * (Shared mode is similar but may involve cascading signals.)
--- 136,152 ----
   * <p>Even though this class is based on an internal FIFO queue, it
   * does not automatically enforce FIFO acquisition policies.  The core
   * of exclusive synchronization takes the form:
   *
   * <pre>
!  * <em>Acquire:</em>
   *     while (!tryAcquire(arg)) {
   *        <em>enqueue thread if it is not already queued</em>;
   *        <em>possibly block current thread</em>;
   *     }
   *
!  * <em>Release:</em>
   *     if (tryRelease(arg))
   *        <em>unblock the first queued thread</em>;
   * </pre>
   *
   * (Shared mode is similar but may involve cascading signals.)
*** 1563,1579 ****
           */
          public final void awaitUninterruptibly() {
              ConditionNode node = new ConditionNode();
              int savedState = enableWait(node);
              LockSupport.setCurrentBlocker(this); // for back-compatibility
!             boolean interrupted = false;
              while (!canReacquire(node)) {
                  if (Thread.interrupted())
                      interrupted = true;
                  else if ((node.status & COND) != 0) {
                      try {
                          ForkJoinPool.managedBlock(node);
                      } catch (InterruptedException ie) {
                          interrupted = true;
                      }
                  } else
                      Thread.onSpinWait();    // awoke while enqueuing
--- 1564,1585 ----
           */
          public final void awaitUninterruptibly() {
              ConditionNode node = new ConditionNode();
              int savedState = enableWait(node);
              LockSupport.setCurrentBlocker(this); // for back-compatibility
!             boolean interrupted = false, rejected = false;
              while (!canReacquire(node)) {
                  if (Thread.interrupted())
                      interrupted = true;
                  else if ((node.status & COND) != 0) {
                      try {
+                         if (rejected)
+                             node.block();
+                         else
                              ForkJoinPool.managedBlock(node);
+                     } catch (RejectedExecutionException ex) {
+                         rejected = true;
                      } catch (InterruptedException ie) {
                          interrupted = true;
                      }
                  } else
                      Thread.onSpinWait();    // awoke while enqueuing
*** 1602,1619 ****
              if (Thread.interrupted())
                  throw new InterruptedException();
              ConditionNode node = new ConditionNode();
              int savedState = enableWait(node);
              LockSupport.setCurrentBlocker(this); // for back-compatibility
!             boolean interrupted = false, cancelled = false;
              while (!canReacquire(node)) {
                  if (interrupted |= Thread.interrupted()) {
                      if (cancelled = (node.getAndUnsetStatus(COND) & COND) != 0)
                          break;              // else interrupted after signal
                  } else if ((node.status & COND) != 0) {
                      try {
                          ForkJoinPool.managedBlock(node);
                      } catch (InterruptedException ie) {
                          interrupted = true;
                      }
                  } else
                      Thread.onSpinWait();    // awoke while enqueuing
--- 1608,1630 ----
              if (Thread.interrupted())
                  throw new InterruptedException();
              ConditionNode node = new ConditionNode();
              int savedState = enableWait(node);
              LockSupport.setCurrentBlocker(this); // for back-compatibility
!             boolean interrupted = false, cancelled = false, rejected = false;
              while (!canReacquire(node)) {
                  if (interrupted |= Thread.interrupted()) {
                      if (cancelled = (node.getAndUnsetStatus(COND) & COND) != 0)
                          break;              // else interrupted after signal
                  } else if ((node.status & COND) != 0) {
                      try {
+                         if (rejected)
+                             node.block();
+                         else
                              ForkJoinPool.managedBlock(node);
+                     } catch (RejectedExecutionException ex) {
+                         rejected = true;
                      } catch (InterruptedException ie) {
                          interrupted = true;
                      }
                  } else
                      Thread.onSpinWait();    // awoke while enqueuing