jdk-sandbox: comparison src/java.base/share/classes/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java

equal deleted inserted replaced

-:20ed1cebe5f8
+:221cf8307606
 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.
+// or signal, so no further action is necessary, although with
+// a possibility that a cancelled node may transiently remain
+// reachable.
 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.
 * Queries whether any threads are waiting to acquire. Note that
 * because cancellations due to interrupts and timeouts may occur
 * at any time, a {@code true} return does not guarantee that any
 * other thread will ever acquire.
 *
-* <p>In this implementation, this operation returns in
-* constant time.
-*
 * @return {@code true} if there may be other threads waiting to acquire
 */
 public final boolean hasQueuedThreads() {
-return head != tail;
+for (Node p = tail, h = head; p != h && p != null; p = p.prev)
+if (p.waitStatus <= 0)
+return true;
+return false;
 }
 /**
 * Queries whether any threads have ever contended to acquire this
 * synchronizer; that is, if an acquire method has ever blocked.
 *         current thread, and {@code false} if the current thread
 *         is at the head of the queue or the queue is empty
 * @since 1.7
 */
 public final boolean hasQueuedPredecessors() {
-// The correctness of this depends on head being initialized
+Node h, s;
-// before tail and on head.next being accurate if the current
+if ((h = head) != null) {
-// thread is first in queue.
+if ((s = h.next) == null || s.waitStatus > 0) {
-Node t = tail; // Read fields in reverse initialization order
+s = null; // traverse in case of concurrent cancellation
-Node h = head;
+for (Node p = tail; p != h && p != null; p = p.prev) {
-Node s;
+if (p.waitStatus <= 0)
-return h != t &&
+s = p;
-((s = h.next) == null || s.thread != Thread.currentThread());
+}
 }
+if (s != null && s.thread != Thread.currentThread())
+return true;
+}
+return false;
+}
 // Instrumentation and monitoring methods
 /**
 * Returns an estimate of the number of threads waiting to

changeset 48540	221cf8307606
parent 48046	98801bd22f5b
child 49565	b5705ade8c8d