From eb5a806625720beedfa5e88d28f0985ffb3a8235 Mon Sep 17 00:00:00 2001
From: "copybara-service[bot]" <copybara-service[bot]@users.noreply.github.com>
Date: Fri, 3 Jan 2025 14:53:08 +0000
Subject: [PATCH] Generate Javadoc and JDiff for Guava HEAD-jre-SNAPSHOT

---
 .../api/docs/member-search-index.zip          |  Bin 49810 -> 49810 bytes
 .../api/docs/package-search-index.zip         |  Bin 322 -> 322 bytes
 .../api/docs/type-search-index.zip            |  Bin 3363 -> 3363 bytes
 .../util/concurrent/AbstractFuture.html       |   34 +-
 .../api/docs/member-search-index.zip          |  Bin 50705 -> 50705 bytes
 .../api/docs/package-search-index.zip         |  Bin 322 -> 322 bytes
 .../util/concurrent/AbstractFuture.html       | 3166 +++++++++--------
 .../api/docs/type-search-index.zip            |  Bin 3363 -> 3363 bytes
 8 files changed, 1664 insertions(+), 1536 deletions(-)

diff --git a/releases/snapshot-android/api/docs/member-search-index.zip b/releases/snapshot-android/api/docs/member-search-index.zip
index 8a69261fa6781babf5c67957c6e9ba9bf70b5374..d731d866bef6fc0803b880259e32b8f0191430fe 100644
GIT binary patch
delta 32
mcmbQ#$~>u+nK!_jnMH(wgM))%Vwv(rUeiO&Kzg$4AzuK6J_!Q=

delta 32
mcmbQ#$~>u+nK!_jnMH(wgM)*iaIw-xUeiO&Kzg$4AzuK6@Ch3L

diff --git a/releases/snapshot-android/api/docs/package-search-index.zip b/releases/snapshot-android/api/docs/package-search-index.zip
index 7e953582cb006e291f41631cc6d307475de9260d..0d8ee4613d54d231f4eaaaac09145e842ce1207b 100644
GIT binary patch
delta 28
hcmX@abcl&Jz?+#xgn@&DgJEKs@<iSz%pmHE9{^#v2oL}O

delta 28
hcmX@abcl&Jz?+#xgn@&DgQ0M-(nQ`T%pmHE9{^%T2q*vm

diff --git a/releases/snapshot-android/api/docs/type-search-index.zip b/releases/snapshot-android/api/docs/type-search-index.zip
index 05d85e51570ea583395f03b166047574f871ecb8..17d7c7325447467dff0ff72b49a36fbaee49420d 100644
GIT binary patch
delta 30
kcmZ21wOEQbz?+#xgn@&DgJEKs@<!ehJj_6P@(mtu0BvCi0RR91

delta 30
kcmZ21wOEQbz?+#xgn@&DgQ0M-(nj7BJj_6P@(mtu0B#cq82|tP

diff --git a/releases/snapshot-jre/api/docs/com/google/common/util/concurrent/AbstractFuture.html b/releases/snapshot-jre/api/docs/com/google/common/util/concurrent/AbstractFuture.html
index 06ddc5137c8f..01cd9c3e6d8a 100644
--- a/releases/snapshot-jre/api/docs/com/google/common/util/concurrent/AbstractFuture.html
+++ b/releases/snapshot-jre/api/docs/com/google/common/util/concurrent/AbstractFuture.html
@@ -147,7 +147,7 @@ <h2 title="Class AbstractFuture" class="title">Class AbstractFuture&lt;V extends
 <hr>
 <pre><a href="../../annotations/GwtCompatible.html" title="annotation in com.google.common.annotations">@GwtCompatible</a>(<a href="../../annotations/GwtCompatible.html#emulated()">emulated</a>=true)
 <a href="https://static.javadoc.io/com.google.j2objc/j2objc-annotations/1.1/com/google/j2objc/annotations/ReflectionSupport.html?is-external=true" title="class or interface in com.google.j2objc.annotations" class="externalLink">@ReflectionSupport</a>(<a href="https://static.javadoc.io/com.google.j2objc/j2objc-annotations/1.1/com/google/j2objc/annotations/ReflectionSupport.Level.html?is-external=true#FULL" title="class or interface in com.google.j2objc.annotations" class="externalLink">FULL</a>)
-public abstract class <a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.71">AbstractFuture</a>&lt;V extends @Nullable <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a>&gt;
+public abstract class <a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.74">AbstractFuture</a>&lt;V extends @Nullable <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a>&gt;
 extends com.google.common.util.concurrent.internal.InternalFutureFailureAccess
 implements <a href="ListenableFuture.html" title="interface in com.google.common.util.concurrent">ListenableFuture</a>&lt;V&gt;</pre>
 <div class="block">An abstract implementation of <a href="ListenableFuture.html" title="interface in com.google.common.util.concurrent"><code>ListenableFuture</code></a>, intended for advanced users only. More
@@ -338,7 +338,7 @@ <h3>Constructor Detail</h3>
 <ul class="blockListLast">
 <li class="blockList">
 <h4>AbstractFuture</h4>
-<pre>protected&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.400">AbstractFuture</a>()</pre>
+<pre>protected&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.462">AbstractFuture</a>()</pre>
 <div class="block">Constructor for use by subclasses.</div>
 </li>
 </ul>
@@ -359,7 +359,7 @@ <h3>Method Detail</h3>
 <li class="blockList">
 <h4>get</h4>
 <pre class="methodSignature"><a href="https://errorprone.info/api/latest/com/google/errorprone/annotations/CanIgnoreReturnValue.html?is-external=true" title="class or interface in com.google.errorprone.annotations" class="externalLink">@CanIgnoreReturnValue</a>
-public&nbsp;<a href="AbstractFuture.html" title="type parameter in AbstractFuture">V</a>&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.434">get</a>&#8203;(long&nbsp;timeout,
+public&nbsp;<a href="AbstractFuture.html" title="type parameter in AbstractFuture">V</a>&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.496">get</a>&#8203;(long&nbsp;timeout,
              <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/util/concurrent/TimeUnit.html?is-external=true" title="class or interface in java.util.concurrent" class="externalLink">TimeUnit</a>&nbsp;unit)
       throws <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang" class="externalLink">InterruptedException</a>,
              <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/util/concurrent/TimeoutException.html?is-external=true" title="class or interface in java.util.concurrent" class="externalLink">TimeoutException</a>,
@@ -386,7 +386,7 @@ <h4>get</h4>
 <li class="blockList">
 <h4>get</h4>
 <pre class="methodSignature"><a href="https://errorprone.info/api/latest/com/google/errorprone/annotations/CanIgnoreReturnValue.html?is-external=true" title="class or interface in com.google.errorprone.annotations" class="externalLink">@CanIgnoreReturnValue</a>
-public&nbsp;<a href="AbstractFuture.html" title="type parameter in AbstractFuture">V</a>&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.548">get</a>()
+public&nbsp;<a href="AbstractFuture.html" title="type parameter in AbstractFuture">V</a>&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.610">get</a>()
       throws <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang" class="externalLink">InterruptedException</a>,
              <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/util/concurrent/ExecutionException.html?is-external=true" title="class or interface in java.util.concurrent" class="externalLink">ExecutionException</a></pre>
 <div class="block">
@@ -409,7 +409,7 @@ <h4>get</h4>
 <ul class="blockList">
 <li class="blockList">
 <h4>isDone</h4>
-<pre class="methodSignature">public&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.616">isDone</a>()</pre>
+<pre class="methodSignature">public&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.678">isDone</a>()</pre>
 <dl>
 <dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
 <dd><code><a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/util/concurrent/Future.html?is-external=true#isDone()" title="class or interface in java.util.concurrent" class="externalLink">isDone</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/util/concurrent/Future.html?is-external=true" title="class or interface in java.util.concurrent" class="externalLink">Future</a>&lt;<a href="AbstractFuture.html" title="type parameter in AbstractFuture">V</a> extends @Nullable <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a>&gt;</code></dd>
@@ -422,7 +422,7 @@ <h4>isDone</h4>
 <ul class="blockList">
 <li class="blockList">
 <h4>isCancelled</h4>
-<pre class="methodSignature">public&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.622">isCancelled</a>()</pre>
+<pre class="methodSignature">public&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.684">isCancelled</a>()</pre>
 <dl>
 <dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
 <dd><code><a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/util/concurrent/Future.html?is-external=true#isCancelled()" title="class or interface in java.util.concurrent" class="externalLink">isCancelled</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/util/concurrent/Future.html?is-external=true" title="class or interface in java.util.concurrent" class="externalLink">Future</a>&lt;<a href="AbstractFuture.html" title="type parameter in AbstractFuture">V</a> extends @Nullable <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a>&gt;</code></dd>
@@ -436,7 +436,7 @@ <h4>isCancelled</h4>
 <li class="blockList">
 <h4>cancel</h4>
 <pre class="methodSignature"><a href="https://errorprone.info/api/latest/com/google/errorprone/annotations/CanIgnoreReturnValue.html?is-external=true" title="class or interface in com.google.errorprone.annotations" class="externalLink">@CanIgnoreReturnValue</a>
-public&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.644">cancel</a>&#8203;(boolean&nbsp;mayInterruptIfRunning)</pre>
+public&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.706">cancel</a>&#8203;(boolean&nbsp;mayInterruptIfRunning)</pre>
 <div class="block">
 
  <p>If a cancellation attempt succeeds on a <code>Future</code> that had previously been <a href="#setFuture(com.google.common.util.concurrent.ListenableFuture)">set asynchronously</a>, then the cancellation will also be propagated to the delegate
@@ -461,7 +461,7 @@ <h4>cancel</h4>
 <ul class="blockList">
 <li class="blockList">
 <h4>interruptTask</h4>
-<pre class="methodSignature">protected&nbsp;void&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.724">interruptTask</a>()</pre>
+<pre class="methodSignature">protected&nbsp;void&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.786">interruptTask</a>()</pre>
 <div class="block">Subclasses can override this method to implement interruption of the future's computation. The
  method is invoked automatically by a successful call to <a href="#cancel(boolean)"><code>cancel(true)</code></a>.
 
@@ -481,7 +481,7 @@ <h4>interruptTask</h4>
 <ul class="blockList">
 <li class="blockList">
 <h4>wasInterrupted</h4>
-<pre class="methodSignature">protected final&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.732">wasInterrupted</a>()</pre>
+<pre class="methodSignature">protected final&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.794">wasInterrupted</a>()</pre>
 <div class="block">Returns true if this future was cancelled with <code>mayInterruptIfRunning</code> set to <code>
  true</code>.</div>
 <dl>
@@ -496,7 +496,7 @@ <h4>wasInterrupted</h4>
 <ul class="blockList">
 <li class="blockList">
 <h4>addListener</h4>
-<pre class="methodSignature">public&nbsp;void&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.742">addListener</a>&#8203;(<a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/Runnable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Runnable</a>&nbsp;listener,
+<pre class="methodSignature">public&nbsp;void&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.804">addListener</a>&#8203;(<a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/Runnable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Runnable</a>&nbsp;listener,
                         <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/util/concurrent/Executor.html?is-external=true" title="class or interface in java.util.concurrent" class="externalLink">Executor</a>&nbsp;executor)</pre>
 <div class="block">Registers a listener to be <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/util/concurrent/Executor.html?is-external=true#execute(java.lang.Runnable)" title="class or interface in java.util.concurrent" class="externalLink">run</a> on the given executor.
  The listener will run when the <code>Future</code>'s computation is <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/util/concurrent/Future.html?is-external=true#isDone()" title="class or interface in java.util.concurrent" class="externalLink">complete</a> or, if the computation is already complete, immediately.
@@ -541,7 +541,7 @@ <h4>addListener</h4>
 <li class="blockList">
 <h4>set</h4>
 <pre class="methodSignature"><a href="https://errorprone.info/api/latest/com/google/errorprone/annotations/CanIgnoreReturnValue.html?is-external=true" title="class or interface in com.google.errorprone.annotations" class="externalLink">@CanIgnoreReturnValue</a>
-protected&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.788">set</a>&#8203;(<a href="AbstractFuture.html" title="type parameter in AbstractFuture">V</a>&nbsp;value)</pre>
+protected&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.850">set</a>&#8203;(<a href="AbstractFuture.html" title="type parameter in AbstractFuture">V</a>&nbsp;value)</pre>
 <div class="block">Sets the result of this <code>Future</code> unless this <code>Future</code> has already been cancelled or
  set (including <a href="#setFuture(com.google.common.util.concurrent.ListenableFuture)">set asynchronously</a>). When a call to this method returns,
  the <code>Future</code> is guaranteed to be <a href="#isDone()">done</a> <b>only if</b> the call was
@@ -567,7 +567,7 @@ <h4>set</h4>
 <li class="blockList">
 <h4>setException</h4>
 <pre class="methodSignature"><a href="https://errorprone.info/api/latest/com/google/errorprone/annotations/CanIgnoreReturnValue.html?is-external=true" title="class or interface in com.google.errorprone.annotations" class="externalLink">@CanIgnoreReturnValue</a>
-protected&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.813">setException</a>&#8203;(<a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/Throwable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Throwable</a>&nbsp;throwable)</pre>
+protected&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.875">setException</a>&#8203;(<a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/Throwable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Throwable</a>&nbsp;throwable)</pre>
 <div class="block">Sets the failed result of this <code>Future</code> unless this <code>Future</code> has already been
  cancelled or set (including <a href="#setFuture(com.google.common.util.concurrent.ListenableFuture)">set asynchronously</a>). When a call to this
  method returns, the <code>Future</code> is guaranteed to be <a href="#isDone()">done</a> <b>only if</b>
@@ -593,7 +593,7 @@ <h4>setException</h4>
 <li class="blockList">
 <h4>setFuture</h4>
 <pre class="methodSignature"><a href="https://errorprone.info/api/latest/com/google/errorprone/annotations/CanIgnoreReturnValue.html?is-external=true" title="class or interface in com.google.errorprone.annotations" class="externalLink">@CanIgnoreReturnValue</a>
-protected&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.852">setFuture</a>&#8203;(<a href="ListenableFuture.html" title="interface in com.google.common.util.concurrent">ListenableFuture</a>&lt;? extends <a href="AbstractFuture.html" title="type parameter in AbstractFuture">V</a>&gt;&nbsp;future)</pre>
+protected&nbsp;boolean&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.914">setFuture</a>&#8203;(<a href="ListenableFuture.html" title="interface in com.google.common.util.concurrent">ListenableFuture</a>&lt;? extends <a href="AbstractFuture.html" title="type parameter in AbstractFuture">V</a>&gt;&nbsp;future)</pre>
 <div class="block">Sets the result of this <code>Future</code> to match the supplied input <code>Future</code> once the
  supplied <code>Future</code> is done, unless this <code>Future</code> has already been cancelled or set
  (including "set asynchronously," defined below).
@@ -634,7 +634,7 @@ <h4>setFuture</h4>
 <li class="blockList">
 <h4>afterDone</h4>
 <pre class="methodSignature"><a href="https://errorprone.info/api/latest/com/google/errorprone/annotations/ForOverride.html?is-external=true" title="class or interface in com.google.errorprone.annotations" class="externalLink">@ForOverride</a>
-protected&nbsp;void&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.1086">afterDone</a>()</pre>
+protected&nbsp;void&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.1148">afterDone</a>()</pre>
 <div class="block">Callback method that is called exactly once after the future is completed.
 
  <p>If <a href="#interruptTask()"><code>interruptTask()</code></a> is also run during completion, <a href="#afterDone()"><code>afterDone()</code></a> runs after it.
@@ -654,7 +654,7 @@ <h4>afterDone</h4>
 <ul class="blockList">
 <li class="blockList">
 <h4>tryInternalFastPathGetFailure</h4>
-<pre class="methodSignature">protected final&nbsp;@Nullable <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/Throwable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Throwable</a>&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.1110">tryInternalFastPathGetFailure</a>()</pre>
+<pre class="methodSignature">protected final&nbsp;@Nullable <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/Throwable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Throwable</a>&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.1172">tryInternalFastPathGetFailure</a>()</pre>
 <div class="block">Usually returns <code>null</code> but, if this <code>Future</code> has failed, may <i>optionally</i>
  return the cause of the failure. "Failure" means specifically "completed with an exception"; it
  does not include "was cancelled." To be explicit: If this method returns a non-null value,
@@ -684,7 +684,7 @@ <h4>tryInternalFastPathGetFailure</h4>
 <ul class="blockList">
 <li class="blockList">
 <h4>toString</h4>
-<pre class="methodSignature">public&nbsp;<a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.1167">toString</a>()</pre>
+<pre class="methodSignature">public&nbsp;<a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.1229">toString</a>()</pre>
 <dl>
 <dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
 <dd><code><a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/Object.html?is-external=true#toString()" title="class or interface in java.lang" class="externalLink">toString</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a></code></dd>
@@ -697,7 +697,7 @@ <h4>toString</h4>
 <ul class="blockListLast">
 <li class="blockList">
 <h4>pendingToString</h4>
-<pre class="methodSignature">protected&nbsp;@Nullable <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.1193">pendingToString</a>()</pre>
+<pre class="methodSignature">protected&nbsp;@Nullable <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/AbstractFuture.html#line.1255">pendingToString</a>()</pre>
 <div class="block">Provide a human-readable explanation of why this future has not yet completed.</div>
 <dl>
 <dt><span class="returnLabel">Returns:</span></dt>
diff --git a/releases/snapshot-jre/api/docs/member-search-index.zip b/releases/snapshot-jre/api/docs/member-search-index.zip
index 7d0c0d4720949fe84d2393444461de6f0c1b0a9d..4819c72d55c8021d9fa845dd39bfda3597500e43 100644
GIT binary patch
delta 32
mcmbQ(!#uHvnK!_jnMH(wgM)*is!Vw!@0O#?Kzj0#qrL!(I0@wd

delta 32
mcmbQ(!#uHvnK!_jnMH(wgM))1YO&Hr-YrL&f%N1fM|}Z{>IwY-

diff --git a/releases/snapshot-jre/api/docs/package-search-index.zip b/releases/snapshot-jre/api/docs/package-search-index.zip
index f56420027831445e6574930e9a2d3f6dc6f8fd0f..591c6b13ff33d3a9e3dbf0124db262e80f463d8c 100644
GIT binary patch
delta 28
hcmX@abcl&Jz?+#xgn@&DgQ2QSc_Qx<W)Sto4**~T2jTz#

delta 28
hcmX@abcl&Jz?+#xgn@&DgCT0M(nQ`T%pmHE9{^yH2l@a2

diff --git a/releases/snapshot-jre/api/docs/src-html/com/google/common/util/concurrent/AbstractFuture.html b/releases/snapshot-jre/api/docs/src-html/com/google/common/util/concurrent/AbstractFuture.html
index 9f661424af78..446997dd256e 100644
--- a/releases/snapshot-jre/api/docs/src-html/com/google/common/util/concurrent/AbstractFuture.html
+++ b/releases/snapshot-jre/api/docs/src-html/com/google/common/util/concurrent/AbstractFuture.html
@@ -38,1543 +38,1671 @@
 <span class="sourceLineNo">029</span><a id="line.29">import com.google.common.util.concurrent.internal.InternalFutures;</a>
 <span class="sourceLineNo">030</span><a id="line.30">import com.google.errorprone.annotations.CanIgnoreReturnValue;</a>
 <span class="sourceLineNo">031</span><a id="line.31">import com.google.errorprone.annotations.ForOverride;</a>
-<span class="sourceLineNo">032</span><a id="line.32">import com.google.j2objc.annotations.ReflectionSupport;</a>
-<span class="sourceLineNo">033</span><a id="line.33">import com.google.j2objc.annotations.RetainedLocalRef;</a>
-<span class="sourceLineNo">034</span><a id="line.34">import java.lang.reflect.Field;</a>
-<span class="sourceLineNo">035</span><a id="line.35">import java.security.AccessController;</a>
-<span class="sourceLineNo">036</span><a id="line.36">import java.security.PrivilegedActionException;</a>
-<span class="sourceLineNo">037</span><a id="line.37">import java.security.PrivilegedExceptionAction;</a>
-<span class="sourceLineNo">038</span><a id="line.38">import java.util.Locale;</a>
-<span class="sourceLineNo">039</span><a id="line.39">import java.util.concurrent.CancellationException;</a>
-<span class="sourceLineNo">040</span><a id="line.40">import java.util.concurrent.ExecutionException;</a>
-<span class="sourceLineNo">041</span><a id="line.41">import java.util.concurrent.Executor;</a>
-<span class="sourceLineNo">042</span><a id="line.42">import java.util.concurrent.Future;</a>
-<span class="sourceLineNo">043</span><a id="line.43">import java.util.concurrent.ScheduledFuture;</a>
-<span class="sourceLineNo">044</span><a id="line.44">import java.util.concurrent.TimeUnit;</a>
-<span class="sourceLineNo">045</span><a id="line.45">import java.util.concurrent.TimeoutException;</a>
-<span class="sourceLineNo">046</span><a id="line.46">import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;</a>
-<span class="sourceLineNo">047</span><a id="line.47">import java.util.concurrent.locks.LockSupport;</a>
-<span class="sourceLineNo">048</span><a id="line.48">import java.util.logging.Level;</a>
-<span class="sourceLineNo">049</span><a id="line.49">import org.jspecify.annotations.Nullable;</a>
-<span class="sourceLineNo">050</span><a id="line.50">import sun.misc.Unsafe;</a>
-<span class="sourceLineNo">051</span><a id="line.51"></a>
-<span class="sourceLineNo">052</span><a id="line.52">/**</a>
-<span class="sourceLineNo">053</span><a id="line.53"> * An abstract implementation of {@link ListenableFuture}, intended for advanced users only. More</a>
-<span class="sourceLineNo">054</span><a id="line.54"> * common ways to create a {@code ListenableFuture} include instantiating a {@link SettableFuture},</a>
-<span class="sourceLineNo">055</span><a id="line.55"> * submitting a task to a {@link ListeningExecutorService}, and deriving a {@code Future} from an</a>
-<span class="sourceLineNo">056</span><a id="line.56"> * existing one, typically using methods like {@link Futures#transform(ListenableFuture,</a>
-<span class="sourceLineNo">057</span><a id="line.57"> * com.google.common.base.Function, java.util.concurrent.Executor) Futures.transform} and {@link</a>
-<span class="sourceLineNo">058</span><a id="line.58"> * Futures#catching(ListenableFuture, Class, com.google.common.base.Function,</a>
-<span class="sourceLineNo">059</span><a id="line.59"> * java.util.concurrent.Executor) Futures.catching}.</a>
-<span class="sourceLineNo">060</span><a id="line.60"> *</a>
-<span class="sourceLineNo">061</span><a id="line.61"> * &lt;p&gt;This class implements all methods in {@code ListenableFuture}. Subclasses should provide a way</a>
-<span class="sourceLineNo">062</span><a id="line.62"> * to set the result of the computation through the protected methods {@link #set(Object)}, {@link</a>
-<span class="sourceLineNo">063</span><a id="line.63"> * #setFuture(ListenableFuture)} and {@link #setException(Throwable)}. Subclasses may also override</a>
-<span class="sourceLineNo">064</span><a id="line.64"> * {@link #afterDone()}, which will be invoked automatically when the future completes. Subclasses</a>
-<span class="sourceLineNo">065</span><a id="line.65"> * should rarely override other methods.</a>
-<span class="sourceLineNo">066</span><a id="line.66"> *</a>
-<span class="sourceLineNo">067</span><a id="line.67"> * @author Sven Mawson</a>
-<span class="sourceLineNo">068</span><a id="line.68"> * @author Luke Sandberg</a>
-<span class="sourceLineNo">069</span><a id="line.69"> * @since 1.0</a>
-<span class="sourceLineNo">070</span><a id="line.70"> */</a>
-<span class="sourceLineNo">071</span><a id="line.71">@SuppressWarnings({</a>
-<span class="sourceLineNo">072</span><a id="line.72">  // Whenever both tests are cheap and functional, it's faster to use &amp;, | instead of &amp;&amp;, ||</a>
-<span class="sourceLineNo">073</span><a id="line.73">  "ShortCircuitBoolean",</a>
-<span class="sourceLineNo">074</span><a id="line.74">  "nullness", // TODO(b/147136275): Remove once our checker understands &amp; and |.</a>
-<span class="sourceLineNo">075</span><a id="line.75">})</a>
-<span class="sourceLineNo">076</span><a id="line.76">@GwtCompatible(emulated = true)</a>
-<span class="sourceLineNo">077</span><a id="line.77">@ReflectionSupport(value = ReflectionSupport.Level.FULL)</a>
-<span class="sourceLineNo">078</span><a id="line.78">public abstract class AbstractFuture&lt;V extends @Nullable Object&gt; extends InternalFutureFailureAccess</a>
-<span class="sourceLineNo">079</span><a id="line.79">    implements ListenableFuture&lt;V&gt; {</a>
-<span class="sourceLineNo">080</span><a id="line.80">  static final boolean GENERATE_CANCELLATION_CAUSES;</a>
-<span class="sourceLineNo">081</span><a id="line.81"></a>
-<span class="sourceLineNo">082</span><a id="line.82">  static {</a>
-<span class="sourceLineNo">083</span><a id="line.83">    // System.getProperty may throw if the security policy does not permit access.</a>
-<span class="sourceLineNo">084</span><a id="line.84">    boolean generateCancellationCauses;</a>
-<span class="sourceLineNo">085</span><a id="line.85">    try {</a>
-<span class="sourceLineNo">086</span><a id="line.86">      generateCancellationCauses =</a>
-<span class="sourceLineNo">087</span><a id="line.87">          Boolean.parseBoolean(</a>
-<span class="sourceLineNo">088</span><a id="line.88">              System.getProperty("guava.concurrent.generate_cancellation_cause", "false"));</a>
-<span class="sourceLineNo">089</span><a id="line.89">    } catch (SecurityException e) {</a>
-<span class="sourceLineNo">090</span><a id="line.90">      generateCancellationCauses = false;</a>
-<span class="sourceLineNo">091</span><a id="line.91">    }</a>
-<span class="sourceLineNo">092</span><a id="line.92">    GENERATE_CANCELLATION_CAUSES = generateCancellationCauses;</a>
-<span class="sourceLineNo">093</span><a id="line.93">  }</a>
-<span class="sourceLineNo">094</span><a id="line.94"></a>
-<span class="sourceLineNo">095</span><a id="line.95">  /**</a>
-<span class="sourceLineNo">096</span><a id="line.96">   * Tag interface marking trusted subclasses. This enables some optimizations. The implementation</a>
-<span class="sourceLineNo">097</span><a id="line.97">   * of this interface must also be an AbstractFuture and must not override or expose for overriding</a>
-<span class="sourceLineNo">098</span><a id="line.98">   * any of the public methods of ListenableFuture.</a>
-<span class="sourceLineNo">099</span><a id="line.99">   */</a>
-<span class="sourceLineNo">100</span><a id="line.100">  interface Trusted&lt;V extends @Nullable Object&gt; extends ListenableFuture&lt;V&gt; {}</a>
-<span class="sourceLineNo">101</span><a id="line.101"></a>
-<span class="sourceLineNo">102</span><a id="line.102">  /**</a>
-<span class="sourceLineNo">103</span><a id="line.103">   * A less abstract subclass of AbstractFuture. This can be used to optimize setFuture by ensuring</a>
-<span class="sourceLineNo">104</span><a id="line.104">   * that {@link #get} calls exactly the implementation of {@link AbstractFuture#get}.</a>
-<span class="sourceLineNo">105</span><a id="line.105">   */</a>
-<span class="sourceLineNo">106</span><a id="line.106">  abstract static class TrustedFuture&lt;V extends @Nullable Object&gt; extends AbstractFuture&lt;V&gt;</a>
-<span class="sourceLineNo">107</span><a id="line.107">      implements Trusted&lt;V&gt; {</a>
-<span class="sourceLineNo">108</span><a id="line.108">    @CanIgnoreReturnValue</a>
-<span class="sourceLineNo">109</span><a id="line.109">    @Override</a>
-<span class="sourceLineNo">110</span><a id="line.110">    @ParametricNullness</a>
-<span class="sourceLineNo">111</span><a id="line.111">    public final V get() throws InterruptedException, ExecutionException {</a>
-<span class="sourceLineNo">112</span><a id="line.112">      return super.get();</a>
-<span class="sourceLineNo">113</span><a id="line.113">    }</a>
-<span class="sourceLineNo">114</span><a id="line.114"></a>
-<span class="sourceLineNo">115</span><a id="line.115">    @CanIgnoreReturnValue</a>
-<span class="sourceLineNo">116</span><a id="line.116">    @Override</a>
-<span class="sourceLineNo">117</span><a id="line.117">    @ParametricNullness</a>
-<span class="sourceLineNo">118</span><a id="line.118">    public final V get(long timeout, TimeUnit unit)</a>
-<span class="sourceLineNo">119</span><a id="line.119">        throws InterruptedException, ExecutionException, TimeoutException {</a>
-<span class="sourceLineNo">120</span><a id="line.120">      return super.get(timeout, unit);</a>
-<span class="sourceLineNo">121</span><a id="line.121">    }</a>
-<span class="sourceLineNo">122</span><a id="line.122"></a>
-<span class="sourceLineNo">123</span><a id="line.123">    @Override</a>
-<span class="sourceLineNo">124</span><a id="line.124">    public final boolean isDone() {</a>
-<span class="sourceLineNo">125</span><a id="line.125">      return super.isDone();</a>
-<span class="sourceLineNo">126</span><a id="line.126">    }</a>
-<span class="sourceLineNo">127</span><a id="line.127"></a>
-<span class="sourceLineNo">128</span><a id="line.128">    @Override</a>
-<span class="sourceLineNo">129</span><a id="line.129">    public final boolean isCancelled() {</a>
-<span class="sourceLineNo">130</span><a id="line.130">      return super.isCancelled();</a>
-<span class="sourceLineNo">131</span><a id="line.131">    }</a>
-<span class="sourceLineNo">132</span><a id="line.132"></a>
-<span class="sourceLineNo">133</span><a id="line.133">    @Override</a>
-<span class="sourceLineNo">134</span><a id="line.134">    public final void addListener(Runnable listener, Executor executor) {</a>
-<span class="sourceLineNo">135</span><a id="line.135">      super.addListener(listener, executor);</a>
-<span class="sourceLineNo">136</span><a id="line.136">    }</a>
-<span class="sourceLineNo">137</span><a id="line.137"></a>
-<span class="sourceLineNo">138</span><a id="line.138">    @CanIgnoreReturnValue</a>
-<span class="sourceLineNo">139</span><a id="line.139">    @Override</a>
-<span class="sourceLineNo">140</span><a id="line.140">    public final boolean cancel(boolean mayInterruptIfRunning) {</a>
-<span class="sourceLineNo">141</span><a id="line.141">      return super.cancel(mayInterruptIfRunning);</a>
-<span class="sourceLineNo">142</span><a id="line.142">    }</a>
-<span class="sourceLineNo">143</span><a id="line.143">  }</a>
-<span class="sourceLineNo">144</span><a id="line.144"></a>
-<span class="sourceLineNo">145</span><a id="line.145">  static final LazyLogger log = new LazyLogger(AbstractFuture.class);</a>
-<span class="sourceLineNo">146</span><a id="line.146"></a>
-<span class="sourceLineNo">147</span><a id="line.147">  // A heuristic for timed gets. If the remaining timeout is less than this, spin instead of</a>
-<span class="sourceLineNo">148</span><a id="line.148">  // blocking. This value is what AbstractQueuedSynchronizer uses.</a>
-<span class="sourceLineNo">149</span><a id="line.149">  private static final long SPIN_THRESHOLD_NANOS = 1000L;</a>
-<span class="sourceLineNo">150</span><a id="line.150"></a>
-<span class="sourceLineNo">151</span><a id="line.151">  private static final AtomicHelper ATOMIC_HELPER;</a>
-<span class="sourceLineNo">152</span><a id="line.152"></a>
-<span class="sourceLineNo">153</span><a id="line.153">  static {</a>
-<span class="sourceLineNo">154</span><a id="line.154">    AtomicHelper helper;</a>
-<span class="sourceLineNo">155</span><a id="line.155">    Throwable thrownUnsafeFailure = null;</a>
-<span class="sourceLineNo">156</span><a id="line.156">    Throwable thrownAtomicReferenceFieldUpdaterFailure = null;</a>
-<span class="sourceLineNo">157</span><a id="line.157"></a>
-<span class="sourceLineNo">158</span><a id="line.158">    try {</a>
-<span class="sourceLineNo">159</span><a id="line.159">      helper = new UnsafeAtomicHelper();</a>
-<span class="sourceLineNo">160</span><a id="line.160">    } catch (Exception | Error unsafeFailure) { // sneaky checked exception</a>
-<span class="sourceLineNo">161</span><a id="line.161">      thrownUnsafeFailure = unsafeFailure;</a>
-<span class="sourceLineNo">162</span><a id="line.162">      // catch absolutely everything and fall through to our</a>
-<span class="sourceLineNo">163</span><a id="line.163">      // 'AtomicReferenceFieldUpdaterAtomicHelper' The access control checks that ARFU does means</a>
-<span class="sourceLineNo">164</span><a id="line.164">      // the caller class has to be AbstractFuture instead of</a>
-<span class="sourceLineNo">165</span><a id="line.165">      // AtomicReferenceFieldUpdaterAtomicHelper, so we annoyingly define these here</a>
-<span class="sourceLineNo">166</span><a id="line.166">      try {</a>
-<span class="sourceLineNo">167</span><a id="line.167">        helper =</a>
-<span class="sourceLineNo">168</span><a id="line.168">            new AtomicReferenceFieldUpdaterAtomicHelper(</a>
-<span class="sourceLineNo">169</span><a id="line.169">                newUpdater(Waiter.class, Thread.class, "thread"),</a>
-<span class="sourceLineNo">170</span><a id="line.170">                newUpdater(Waiter.class, Waiter.class, "next"),</a>
-<span class="sourceLineNo">171</span><a id="line.171">                newUpdater(AbstractFuture.class, Waiter.class, "waiters"),</a>
-<span class="sourceLineNo">172</span><a id="line.172">                newUpdater(AbstractFuture.class, Listener.class, "listeners"),</a>
-<span class="sourceLineNo">173</span><a id="line.173">                newUpdater(AbstractFuture.class, Object.class, "value"));</a>
-<span class="sourceLineNo">174</span><a id="line.174">      } catch (Exception // sneaky checked exception</a>
-<span class="sourceLineNo">175</span><a id="line.175">          | Error atomicReferenceFieldUpdaterFailure) {</a>
-<span class="sourceLineNo">176</span><a id="line.176">        // Some Android 5.0.x Samsung devices have bugs in JDK reflection APIs that cause</a>
-<span class="sourceLineNo">177</span><a id="line.177">        // getDeclaredField to throw a NoSuchFieldException when the field is definitely there.</a>
-<span class="sourceLineNo">178</span><a id="line.178">        // For these users fallback to a suboptimal implementation, based on synchronized. This will</a>
-<span class="sourceLineNo">179</span><a id="line.179">        // be a definite performance hit to those users.</a>
-<span class="sourceLineNo">180</span><a id="line.180">        thrownAtomicReferenceFieldUpdaterFailure = atomicReferenceFieldUpdaterFailure;</a>
-<span class="sourceLineNo">181</span><a id="line.181">        helper = new SynchronizedHelper();</a>
-<span class="sourceLineNo">182</span><a id="line.182">      }</a>
-<span class="sourceLineNo">183</span><a id="line.183">    }</a>
-<span class="sourceLineNo">184</span><a id="line.184">    ATOMIC_HELPER = helper;</a>
-<span class="sourceLineNo">185</span><a id="line.185"></a>
-<span class="sourceLineNo">186</span><a id="line.186">    // Prevent rare disastrous classloading in first call to LockSupport.park.</a>
-<span class="sourceLineNo">187</span><a id="line.187">    // See: https://bugs.openjdk.java.net/browse/JDK-8074773</a>
-<span class="sourceLineNo">188</span><a id="line.188">    @SuppressWarnings("unused")</a>
-<span class="sourceLineNo">189</span><a id="line.189">    Class&lt;?&gt; ensureLoaded = LockSupport.class;</a>
-<span class="sourceLineNo">190</span><a id="line.190"></a>
-<span class="sourceLineNo">191</span><a id="line.191">    // Log after all static init is finished; if an installed logger uses any Futures methods, it</a>
-<span class="sourceLineNo">192</span><a id="line.192">    // shouldn't break in cases where reflection is missing/broken.</a>
-<span class="sourceLineNo">193</span><a id="line.193">    if (thrownAtomicReferenceFieldUpdaterFailure != null) {</a>
-<span class="sourceLineNo">194</span><a id="line.194">      log.get().log(Level.SEVERE, "UnsafeAtomicHelper is broken!", thrownUnsafeFailure);</a>
-<span class="sourceLineNo">195</span><a id="line.195">      log.get()</a>
-<span class="sourceLineNo">196</span><a id="line.196">          .log(</a>
-<span class="sourceLineNo">197</span><a id="line.197">              Level.SEVERE,</a>
-<span class="sourceLineNo">198</span><a id="line.198">              "AtomicReferenceFieldUpdaterAtomicHelper is broken!",</a>
-<span class="sourceLineNo">199</span><a id="line.199">              thrownAtomicReferenceFieldUpdaterFailure);</a>
-<span class="sourceLineNo">200</span><a id="line.200">    }</a>
-<span class="sourceLineNo">201</span><a id="line.201">  }</a>
-<span class="sourceLineNo">202</span><a id="line.202"></a>
-<span class="sourceLineNo">203</span><a id="line.203">  /** Waiter links form a Treiber stack, in the {@link #waiters} field. */</a>
-<span class="sourceLineNo">204</span><a id="line.204">  private static final class Waiter {</a>
-<span class="sourceLineNo">205</span><a id="line.205">    static final Waiter TOMBSTONE = new Waiter(false /* ignored param */);</a>
-<span class="sourceLineNo">206</span><a id="line.206"></a>
-<span class="sourceLineNo">207</span><a id="line.207">    volatile @Nullable Thread thread;</a>
-<span class="sourceLineNo">208</span><a id="line.208">    volatile @Nullable Waiter next;</a>
-<span class="sourceLineNo">209</span><a id="line.209"></a>
-<span class="sourceLineNo">210</span><a id="line.210">    /**</a>
-<span class="sourceLineNo">211</span><a id="line.211">     * Constructor for the TOMBSTONE, avoids use of ATOMIC_HELPER in case this class is loaded</a>
-<span class="sourceLineNo">212</span><a id="line.212">     * before the ATOMIC_HELPER. Apparently this is possible on some android platforms.</a>
-<span class="sourceLineNo">213</span><a id="line.213">     */</a>
-<span class="sourceLineNo">214</span><a id="line.214">    Waiter(boolean unused) {}</a>
-<span class="sourceLineNo">215</span><a id="line.215"></a>
-<span class="sourceLineNo">216</span><a id="line.216">    Waiter() {</a>
-<span class="sourceLineNo">217</span><a id="line.217">      // avoid volatile write, write is made visible by subsequent CAS on waiters field</a>
-<span class="sourceLineNo">218</span><a id="line.218">      ATOMIC_HELPER.putThread(this, Thread.currentThread());</a>
-<span class="sourceLineNo">219</span><a id="line.219">    }</a>
-<span class="sourceLineNo">220</span><a id="line.220"></a>
-<span class="sourceLineNo">221</span><a id="line.221">    // non-volatile write to the next field. Should be made visible by subsequent CAS on waiters</a>
-<span class="sourceLineNo">222</span><a id="line.222">    // field.</a>
-<span class="sourceLineNo">223</span><a id="line.223">    void setNext(@Nullable Waiter next) {</a>
-<span class="sourceLineNo">224</span><a id="line.224">      ATOMIC_HELPER.putNext(this, next);</a>
-<span class="sourceLineNo">225</span><a id="line.225">    }</a>
-<span class="sourceLineNo">226</span><a id="line.226"></a>
-<span class="sourceLineNo">227</span><a id="line.227">    void unpark() {</a>
-<span class="sourceLineNo">228</span><a id="line.228">      // This is racy with removeWaiter. The consequence of the race is that we may spuriously call</a>
-<span class="sourceLineNo">229</span><a id="line.229">      // unpark even though the thread has already removed itself from the list. But even if we did</a>
-<span class="sourceLineNo">230</span><a id="line.230">      // use a CAS, that race would still exist (it would just be ever so slightly smaller).</a>
-<span class="sourceLineNo">231</span><a id="line.231">      Thread w = thread;</a>
-<span class="sourceLineNo">232</span><a id="line.232">      if (w != null) {</a>
-<span class="sourceLineNo">233</span><a id="line.233">        thread = null;</a>
-<span class="sourceLineNo">234</span><a id="line.234">        LockSupport.unpark(w);</a>
-<span class="sourceLineNo">235</span><a id="line.235">      }</a>
-<span class="sourceLineNo">236</span><a id="line.236">    }</a>
-<span class="sourceLineNo">237</span><a id="line.237">  }</a>
-<span class="sourceLineNo">238</span><a id="line.238"></a>
-<span class="sourceLineNo">239</span><a id="line.239">  /**</a>
-<span class="sourceLineNo">240</span><a id="line.240">   * Marks the given node as 'deleted' (null waiter) and then scans the list to unlink all deleted</a>
-<span class="sourceLineNo">241</span><a id="line.241">   * nodes. This is an O(n) operation in the common case (and O(n^2) in the worst), but we are saved</a>
-<span class="sourceLineNo">242</span><a id="line.242">   * by two things.</a>
-<span class="sourceLineNo">243</span><a id="line.243">   *</a>
-<span class="sourceLineNo">244</span><a id="line.244">   * &lt;ul&gt;</a>
-<span class="sourceLineNo">245</span><a id="line.245">   *   &lt;li&gt;This is only called when a waiting thread times out or is interrupted. Both of which</a>
-<span class="sourceLineNo">246</span><a id="line.246">   *       should be rare.</a>
-<span class="sourceLineNo">247</span><a id="line.247">   *   &lt;li&gt;The waiters list should be very short.</a>
-<span class="sourceLineNo">248</span><a id="line.248">   * &lt;/ul&gt;</a>
-<span class="sourceLineNo">249</span><a id="line.249">   */</a>
-<span class="sourceLineNo">250</span><a id="line.250">  private void removeWaiter(Waiter node) {</a>
-<span class="sourceLineNo">251</span><a id="line.251">    node.thread = null; // mark as 'deleted'</a>
-<span class="sourceLineNo">252</span><a id="line.252">    restart:</a>
-<span class="sourceLineNo">253</span><a id="line.253">    while (true) {</a>
-<span class="sourceLineNo">254</span><a id="line.254">      Waiter pred = null;</a>
-<span class="sourceLineNo">255</span><a id="line.255">      Waiter curr = waiters;</a>
-<span class="sourceLineNo">256</span><a id="line.256">      if (curr == Waiter.TOMBSTONE) {</a>
-<span class="sourceLineNo">257</span><a id="line.257">        return; // give up if someone is calling complete</a>
-<span class="sourceLineNo">258</span><a id="line.258">      }</a>
-<span class="sourceLineNo">259</span><a id="line.259">      Waiter succ;</a>
-<span class="sourceLineNo">260</span><a id="line.260">      while (curr != null) {</a>
-<span class="sourceLineNo">261</span><a id="line.261">        succ = curr.next;</a>
-<span class="sourceLineNo">262</span><a id="line.262">        if (curr.thread != null) { // we aren't unlinking this node, update pred.</a>
-<span class="sourceLineNo">263</span><a id="line.263">          pred = curr;</a>
-<span class="sourceLineNo">264</span><a id="line.264">        } else if (pred != null) { // We are unlinking this node and it has a predecessor.</a>
-<span class="sourceLineNo">265</span><a id="line.265">          pred.next = succ;</a>
-<span class="sourceLineNo">266</span><a id="line.266">          if (pred.thread == null) { // We raced with another node that unlinked pred. Restart.</a>
-<span class="sourceLineNo">267</span><a id="line.267">            continue restart;</a>
-<span class="sourceLineNo">268</span><a id="line.268">          }</a>
-<span class="sourceLineNo">269</span><a id="line.269">        } else if (!ATOMIC_HELPER.casWaiters(this, curr, succ)) { // We are unlinking head</a>
-<span class="sourceLineNo">270</span><a id="line.270">          continue restart; // We raced with an add or complete</a>
-<span class="sourceLineNo">271</span><a id="line.271">        }</a>
-<span class="sourceLineNo">272</span><a id="line.272">        curr = succ;</a>
-<span class="sourceLineNo">273</span><a id="line.273">      }</a>
-<span class="sourceLineNo">274</span><a id="line.274">      break;</a>
-<span class="sourceLineNo">275</span><a id="line.275">    }</a>
-<span class="sourceLineNo">276</span><a id="line.276">  }</a>
+<span class="sourceLineNo">032</span><a id="line.32">import com.google.j2objc.annotations.J2ObjCIncompatible;</a>
+<span class="sourceLineNo">033</span><a id="line.33">import com.google.j2objc.annotations.ReflectionSupport;</a>
+<span class="sourceLineNo">034</span><a id="line.34">import com.google.j2objc.annotations.RetainedLocalRef;</a>
+<span class="sourceLineNo">035</span><a id="line.35">import java.lang.invoke.MethodHandles;</a>
+<span class="sourceLineNo">036</span><a id="line.36">import java.lang.invoke.VarHandle;</a>
+<span class="sourceLineNo">037</span><a id="line.37">import java.lang.reflect.Field;</a>
+<span class="sourceLineNo">038</span><a id="line.38">import java.security.AccessController;</a>
+<span class="sourceLineNo">039</span><a id="line.39">import java.security.PrivilegedActionException;</a>
+<span class="sourceLineNo">040</span><a id="line.40">import java.security.PrivilegedExceptionAction;</a>
+<span class="sourceLineNo">041</span><a id="line.41">import java.util.Locale;</a>
+<span class="sourceLineNo">042</span><a id="line.42">import java.util.concurrent.CancellationException;</a>
+<span class="sourceLineNo">043</span><a id="line.43">import java.util.concurrent.ExecutionException;</a>
+<span class="sourceLineNo">044</span><a id="line.44">import java.util.concurrent.Executor;</a>
+<span class="sourceLineNo">045</span><a id="line.45">import java.util.concurrent.Future;</a>
+<span class="sourceLineNo">046</span><a id="line.46">import java.util.concurrent.ScheduledFuture;</a>
+<span class="sourceLineNo">047</span><a id="line.47">import java.util.concurrent.TimeUnit;</a>
+<span class="sourceLineNo">048</span><a id="line.48">import java.util.concurrent.TimeoutException;</a>
+<span class="sourceLineNo">049</span><a id="line.49">import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;</a>
+<span class="sourceLineNo">050</span><a id="line.50">import java.util.concurrent.locks.LockSupport;</a>
+<span class="sourceLineNo">051</span><a id="line.51">import java.util.logging.Level;</a>
+<span class="sourceLineNo">052</span><a id="line.52">import org.jspecify.annotations.Nullable;</a>
+<span class="sourceLineNo">053</span><a id="line.53">import sun.misc.Unsafe;</a>
+<span class="sourceLineNo">054</span><a id="line.54"></a>
+<span class="sourceLineNo">055</span><a id="line.55">/**</a>
+<span class="sourceLineNo">056</span><a id="line.56"> * An abstract implementation of {@link ListenableFuture}, intended for advanced users only. More</a>
+<span class="sourceLineNo">057</span><a id="line.57"> * common ways to create a {@code ListenableFuture} include instantiating a {@link SettableFuture},</a>
+<span class="sourceLineNo">058</span><a id="line.58"> * submitting a task to a {@link ListeningExecutorService}, and deriving a {@code Future} from an</a>
+<span class="sourceLineNo">059</span><a id="line.59"> * existing one, typically using methods like {@link Futures#transform(ListenableFuture,</a>
+<span class="sourceLineNo">060</span><a id="line.60"> * com.google.common.base.Function, java.util.concurrent.Executor) Futures.transform} and {@link</a>
+<span class="sourceLineNo">061</span><a id="line.61"> * Futures#catching(ListenableFuture, Class, com.google.common.base.Function,</a>
+<span class="sourceLineNo">062</span><a id="line.62"> * java.util.concurrent.Executor) Futures.catching}.</a>
+<span class="sourceLineNo">063</span><a id="line.63"> *</a>
+<span class="sourceLineNo">064</span><a id="line.64"> * &lt;p&gt;This class implements all methods in {@code ListenableFuture}. Subclasses should provide a way</a>
+<span class="sourceLineNo">065</span><a id="line.65"> * to set the result of the computation through the protected methods {@link #set(Object)}, {@link</a>
+<span class="sourceLineNo">066</span><a id="line.66"> * #setFuture(ListenableFuture)} and {@link #setException(Throwable)}. Subclasses may also override</a>
+<span class="sourceLineNo">067</span><a id="line.67"> * {@link #afterDone()}, which will be invoked automatically when the future completes. Subclasses</a>
+<span class="sourceLineNo">068</span><a id="line.68"> * should rarely override other methods.</a>
+<span class="sourceLineNo">069</span><a id="line.69"> *</a>
+<span class="sourceLineNo">070</span><a id="line.70"> * @author Sven Mawson</a>
+<span class="sourceLineNo">071</span><a id="line.71"> * @author Luke Sandberg</a>
+<span class="sourceLineNo">072</span><a id="line.72"> * @since 1.0</a>
+<span class="sourceLineNo">073</span><a id="line.73"> */</a>
+<span class="sourceLineNo">074</span><a id="line.74">@SuppressWarnings({</a>
+<span class="sourceLineNo">075</span><a id="line.75">  // Whenever both tests are cheap and functional, it's faster to use &amp;, | instead of &amp;&amp;, ||</a>
+<span class="sourceLineNo">076</span><a id="line.76">  "ShortCircuitBoolean",</a>
+<span class="sourceLineNo">077</span><a id="line.77">  "nullness", // TODO(b/147136275): Remove once our checker understands &amp; and |.</a>
+<span class="sourceLineNo">078</span><a id="line.78">})</a>
+<span class="sourceLineNo">079</span><a id="line.79">@GwtCompatible(emulated = true)</a>
+<span class="sourceLineNo">080</span><a id="line.80">@ReflectionSupport(value = ReflectionSupport.Level.FULL)</a>
+<span class="sourceLineNo">081</span><a id="line.81">public abstract class AbstractFuture&lt;V extends @Nullable Object&gt; extends InternalFutureFailureAccess</a>
+<span class="sourceLineNo">082</span><a id="line.82">    implements ListenableFuture&lt;V&gt; {</a>
+<span class="sourceLineNo">083</span><a id="line.83">  static final boolean GENERATE_CANCELLATION_CAUSES;</a>
+<span class="sourceLineNo">084</span><a id="line.84"></a>
+<span class="sourceLineNo">085</span><a id="line.85">  static {</a>
+<span class="sourceLineNo">086</span><a id="line.86">    // System.getProperty may throw if the security policy does not permit access.</a>
+<span class="sourceLineNo">087</span><a id="line.87">    boolean generateCancellationCauses;</a>
+<span class="sourceLineNo">088</span><a id="line.88">    try {</a>
+<span class="sourceLineNo">089</span><a id="line.89">      generateCancellationCauses =</a>
+<span class="sourceLineNo">090</span><a id="line.90">          Boolean.parseBoolean(</a>
+<span class="sourceLineNo">091</span><a id="line.91">              System.getProperty("guava.concurrent.generate_cancellation_cause", "false"));</a>
+<span class="sourceLineNo">092</span><a id="line.92">    } catch (SecurityException e) {</a>
+<span class="sourceLineNo">093</span><a id="line.93">      generateCancellationCauses = false;</a>
+<span class="sourceLineNo">094</span><a id="line.94">    }</a>
+<span class="sourceLineNo">095</span><a id="line.95">    GENERATE_CANCELLATION_CAUSES = generateCancellationCauses;</a>
+<span class="sourceLineNo">096</span><a id="line.96">  }</a>
+<span class="sourceLineNo">097</span><a id="line.97"></a>
+<span class="sourceLineNo">098</span><a id="line.98">  /**</a>
+<span class="sourceLineNo">099</span><a id="line.99">   * Tag interface marking trusted subclasses. This enables some optimizations. The implementation</a>
+<span class="sourceLineNo">100</span><a id="line.100">   * of this interface must also be an AbstractFuture and must not override or expose for overriding</a>
+<span class="sourceLineNo">101</span><a id="line.101">   * any of the public methods of ListenableFuture.</a>
+<span class="sourceLineNo">102</span><a id="line.102">   */</a>
+<span class="sourceLineNo">103</span><a id="line.103">  interface Trusted&lt;V extends @Nullable Object&gt; extends ListenableFuture&lt;V&gt; {}</a>
+<span class="sourceLineNo">104</span><a id="line.104"></a>
+<span class="sourceLineNo">105</span><a id="line.105">  /**</a>
+<span class="sourceLineNo">106</span><a id="line.106">   * A less abstract subclass of AbstractFuture. This can be used to optimize setFuture by ensuring</a>
+<span class="sourceLineNo">107</span><a id="line.107">   * that {@link #get} calls exactly the implementation of {@link AbstractFuture#get}.</a>
+<span class="sourceLineNo">108</span><a id="line.108">   */</a>
+<span class="sourceLineNo">109</span><a id="line.109">  abstract static class TrustedFuture&lt;V extends @Nullable Object&gt; extends AbstractFuture&lt;V&gt;</a>
+<span class="sourceLineNo">110</span><a id="line.110">      implements Trusted&lt;V&gt; {</a>
+<span class="sourceLineNo">111</span><a id="line.111">    @CanIgnoreReturnValue</a>
+<span class="sourceLineNo">112</span><a id="line.112">    @Override</a>
+<span class="sourceLineNo">113</span><a id="line.113">    @ParametricNullness</a>
+<span class="sourceLineNo">114</span><a id="line.114">    public final V get() throws InterruptedException, ExecutionException {</a>
+<span class="sourceLineNo">115</span><a id="line.115">      return super.get();</a>
+<span class="sourceLineNo">116</span><a id="line.116">    }</a>
+<span class="sourceLineNo">117</span><a id="line.117"></a>
+<span class="sourceLineNo">118</span><a id="line.118">    @CanIgnoreReturnValue</a>
+<span class="sourceLineNo">119</span><a id="line.119">    @Override</a>
+<span class="sourceLineNo">120</span><a id="line.120">    @ParametricNullness</a>
+<span class="sourceLineNo">121</span><a id="line.121">    public final V get(long timeout, TimeUnit unit)</a>
+<span class="sourceLineNo">122</span><a id="line.122">        throws InterruptedException, ExecutionException, TimeoutException {</a>
+<span class="sourceLineNo">123</span><a id="line.123">      return super.get(timeout, unit);</a>
+<span class="sourceLineNo">124</span><a id="line.124">    }</a>
+<span class="sourceLineNo">125</span><a id="line.125"></a>
+<span class="sourceLineNo">126</span><a id="line.126">    @Override</a>
+<span class="sourceLineNo">127</span><a id="line.127">    public final boolean isDone() {</a>
+<span class="sourceLineNo">128</span><a id="line.128">      return super.isDone();</a>
+<span class="sourceLineNo">129</span><a id="line.129">    }</a>
+<span class="sourceLineNo">130</span><a id="line.130"></a>
+<span class="sourceLineNo">131</span><a id="line.131">    @Override</a>
+<span class="sourceLineNo">132</span><a id="line.132">    public final boolean isCancelled() {</a>
+<span class="sourceLineNo">133</span><a id="line.133">      return super.isCancelled();</a>
+<span class="sourceLineNo">134</span><a id="line.134">    }</a>
+<span class="sourceLineNo">135</span><a id="line.135"></a>
+<span class="sourceLineNo">136</span><a id="line.136">    @Override</a>
+<span class="sourceLineNo">137</span><a id="line.137">    public final void addListener(Runnable listener, Executor executor) {</a>
+<span class="sourceLineNo">138</span><a id="line.138">      super.addListener(listener, executor);</a>
+<span class="sourceLineNo">139</span><a id="line.139">    }</a>
+<span class="sourceLineNo">140</span><a id="line.140"></a>
+<span class="sourceLineNo">141</span><a id="line.141">    @CanIgnoreReturnValue</a>
+<span class="sourceLineNo">142</span><a id="line.142">    @Override</a>
+<span class="sourceLineNo">143</span><a id="line.143">    public final boolean cancel(boolean mayInterruptIfRunning) {</a>
+<span class="sourceLineNo">144</span><a id="line.144">      return super.cancel(mayInterruptIfRunning);</a>
+<span class="sourceLineNo">145</span><a id="line.145">    }</a>
+<span class="sourceLineNo">146</span><a id="line.146">  }</a>
+<span class="sourceLineNo">147</span><a id="line.147"></a>
+<span class="sourceLineNo">148</span><a id="line.148">  static final LazyLogger log = new LazyLogger(AbstractFuture.class);</a>
+<span class="sourceLineNo">149</span><a id="line.149"></a>
+<span class="sourceLineNo">150</span><a id="line.150">  // A heuristic for timed gets. If the remaining timeout is less than this, spin instead of</a>
+<span class="sourceLineNo">151</span><a id="line.151">  // blocking. This value is what AbstractQueuedSynchronizer uses.</a>
+<span class="sourceLineNo">152</span><a id="line.152">  private static final long SPIN_THRESHOLD_NANOS = 1000L;</a>
+<span class="sourceLineNo">153</span><a id="line.153"></a>
+<span class="sourceLineNo">154</span><a id="line.154">  private static final AtomicHelper ATOMIC_HELPER;</a>
+<span class="sourceLineNo">155</span><a id="line.155"></a>
+<span class="sourceLineNo">156</span><a id="line.156">  /**</a>
+<span class="sourceLineNo">157</span><a id="line.157">   * Returns the result of calling {@link MethodHandles#lookup} from inside {@link AbstractFuture}.</a>
+<span class="sourceLineNo">158</span><a id="line.158">   * By virtue of being created there, it has access to the private fields of {@link</a>
+<span class="sourceLineNo">159</span><a id="line.159">   * AbstractFuture}, so that access is available to anyone who calls this method—specifically, to</a>
+<span class="sourceLineNo">160</span><a id="line.160">   * {@link VarHandleAtomicHelper}.</a>
+<span class="sourceLineNo">161</span><a id="line.161">   *</a>
+<span class="sourceLineNo">162</span><a id="line.162">   * &lt;p&gt;This "shouldn't" be necessary: {@link VarHandleAtomicHelper} and {@link AbstractFuture}</a>
+<span class="sourceLineNo">163</span><a id="line.163">   * "should" be nestmates, so a call to {@link MethodHandles#lookup} inside {@link</a>
+<span class="sourceLineNo">164</span><a id="line.164">   * VarHandleAtomicHelper} "should" have access to each other's private fields. However, our</a>
+<span class="sourceLineNo">165</span><a id="line.165">   * open-source build uses {@code -source 8 -target 8}, so the class files from that build can't</a>
+<span class="sourceLineNo">166</span><a id="line.166">   * express nestmates. Thus, when those class files are used from Java 9 or higher (i.e., high</a>
+<span class="sourceLineNo">167</span><a id="line.167">   * enough to trigger the {@link VarHandle} code path), such a lookup would fail with an {@link</a>
+<span class="sourceLineNo">168</span><a id="line.168">   * IllegalAccessException}.</a>
+<span class="sourceLineNo">169</span><a id="line.169">   *</a>
+<span class="sourceLineNo">170</span><a id="line.170">   * &lt;p&gt;Note that we do not have a similar problem with the fields in {@link Waiter} because those</a>
+<span class="sourceLineNo">171</span><a id="line.171">   * fields are not private. (We could solve the problem with {@link AbstractFuture} fields in the</a>
+<span class="sourceLineNo">172</span><a id="line.172">   * same way if we wanted.)</a>
+<span class="sourceLineNo">173</span><a id="line.173">   */</a>
+<span class="sourceLineNo">174</span><a id="line.174">  private static MethodHandles.Lookup methodHandlesLookupFromWithinAbstractFuture() {</a>
+<span class="sourceLineNo">175</span><a id="line.175">    return MethodHandles.lookup();</a>
+<span class="sourceLineNo">176</span><a id="line.176">  }</a>
+<span class="sourceLineNo">177</span><a id="line.177"></a>
+<span class="sourceLineNo">178</span><a id="line.178">  static {</a>
+<span class="sourceLineNo">179</span><a id="line.179">    AtomicHelper helper;</a>
+<span class="sourceLineNo">180</span><a id="line.180">    Throwable thrownUnsafeFailure = null;</a>
+<span class="sourceLineNo">181</span><a id="line.181">    Throwable thrownAtomicReferenceFieldUpdaterFailure = null;</a>
+<span class="sourceLineNo">182</span><a id="line.182"></a>
+<span class="sourceLineNo">183</span><a id="line.183">    helper = VarHandleAtomicHelperMaker.INSTANCE.tryMakeVarHandleAtomicHelper();</a>
+<span class="sourceLineNo">184</span><a id="line.184">    if (helper == null) {</a>
+<span class="sourceLineNo">185</span><a id="line.185">      try {</a>
+<span class="sourceLineNo">186</span><a id="line.186">        helper = new UnsafeAtomicHelper();</a>
+<span class="sourceLineNo">187</span><a id="line.187">      } catch (Exception | Error unsafeFailure) { // sneaky checked exception</a>
+<span class="sourceLineNo">188</span><a id="line.188">        thrownUnsafeFailure = unsafeFailure;</a>
+<span class="sourceLineNo">189</span><a id="line.189">        // catch absolutely everything and fall through to our</a>
+<span class="sourceLineNo">190</span><a id="line.190">        // 'AtomicReferenceFieldUpdaterAtomicHelper' The access control checks that ARFU does means</a>
+<span class="sourceLineNo">191</span><a id="line.191">        // the caller class has to be AbstractFuture instead of</a>
+<span class="sourceLineNo">192</span><a id="line.192">        // AtomicReferenceFieldUpdaterAtomicHelper, so we annoyingly define these here</a>
+<span class="sourceLineNo">193</span><a id="line.193">        try {</a>
+<span class="sourceLineNo">194</span><a id="line.194">          helper =</a>
+<span class="sourceLineNo">195</span><a id="line.195">              new AtomicReferenceFieldUpdaterAtomicHelper(</a>
+<span class="sourceLineNo">196</span><a id="line.196">                  newUpdater(Waiter.class, Thread.class, "thread"),</a>
+<span class="sourceLineNo">197</span><a id="line.197">                  newUpdater(Waiter.class, Waiter.class, "next"),</a>
+<span class="sourceLineNo">198</span><a id="line.198">                  newUpdater(AbstractFuture.class, Waiter.class, "waiters"),</a>
+<span class="sourceLineNo">199</span><a id="line.199">                  newUpdater(AbstractFuture.class, Listener.class, "listeners"),</a>
+<span class="sourceLineNo">200</span><a id="line.200">                  newUpdater(AbstractFuture.class, Object.class, "value"));</a>
+<span class="sourceLineNo">201</span><a id="line.201">        } catch (Exception // sneaky checked exception</a>
+<span class="sourceLineNo">202</span><a id="line.202">            | Error atomicReferenceFieldUpdaterFailure) {</a>
+<span class="sourceLineNo">203</span><a id="line.203">          // Some Android 5.0.x Samsung devices have bugs in JDK reflection APIs that cause</a>
+<span class="sourceLineNo">204</span><a id="line.204">          // getDeclaredField to throw a NoSuchFieldException when the field is definitely there.</a>
+<span class="sourceLineNo">205</span><a id="line.205">          // For these users fallback to a suboptimal implementation, based on synchronized. This</a>
+<span class="sourceLineNo">206</span><a id="line.206">          // will be a definite performance hit to those users.</a>
+<span class="sourceLineNo">207</span><a id="line.207">          thrownAtomicReferenceFieldUpdaterFailure = atomicReferenceFieldUpdaterFailure;</a>
+<span class="sourceLineNo">208</span><a id="line.208">          helper = new SynchronizedHelper();</a>
+<span class="sourceLineNo">209</span><a id="line.209">        }</a>
+<span class="sourceLineNo">210</span><a id="line.210">      }</a>
+<span class="sourceLineNo">211</span><a id="line.211">    }</a>
+<span class="sourceLineNo">212</span><a id="line.212">    ATOMIC_HELPER = helper;</a>
+<span class="sourceLineNo">213</span><a id="line.213"></a>
+<span class="sourceLineNo">214</span><a id="line.214">    // Prevent rare disastrous classloading in first call to LockSupport.park.</a>
+<span class="sourceLineNo">215</span><a id="line.215">    // See: https://bugs.openjdk.java.net/browse/JDK-8074773</a>
+<span class="sourceLineNo">216</span><a id="line.216">    @SuppressWarnings("unused")</a>
+<span class="sourceLineNo">217</span><a id="line.217">    Class&lt;?&gt; ensureLoaded = LockSupport.class;</a>
+<span class="sourceLineNo">218</span><a id="line.218"></a>
+<span class="sourceLineNo">219</span><a id="line.219">    // Log after all static init is finished; if an installed logger uses any Futures methods, it</a>
+<span class="sourceLineNo">220</span><a id="line.220">    // shouldn't break in cases where reflection is missing/broken.</a>
+<span class="sourceLineNo">221</span><a id="line.221">    if (thrownAtomicReferenceFieldUpdaterFailure != null) {</a>
+<span class="sourceLineNo">222</span><a id="line.222">      log.get().log(Level.SEVERE, "UnsafeAtomicHelper is broken!", thrownUnsafeFailure);</a>
+<span class="sourceLineNo">223</span><a id="line.223">      log.get()</a>
+<span class="sourceLineNo">224</span><a id="line.224">          .log(</a>
+<span class="sourceLineNo">225</span><a id="line.225">              Level.SEVERE,</a>
+<span class="sourceLineNo">226</span><a id="line.226">              "AtomicReferenceFieldUpdaterAtomicHelper is broken!",</a>
+<span class="sourceLineNo">227</span><a id="line.227">              thrownAtomicReferenceFieldUpdaterFailure);</a>
+<span class="sourceLineNo">228</span><a id="line.228">    }</a>
+<span class="sourceLineNo">229</span><a id="line.229">  }</a>
+<span class="sourceLineNo">230</span><a id="line.230"></a>
+<span class="sourceLineNo">231</span><a id="line.231">  private enum VarHandleAtomicHelperMaker {</a>
+<span class="sourceLineNo">232</span><a id="line.232">    INSTANCE {</a>
+<span class="sourceLineNo">233</span><a id="line.233">      /**</a>
+<span class="sourceLineNo">234</span><a id="line.234">       * Implementation used by non-J2ObjC environments (aside, of course, from those that have</a>
+<span class="sourceLineNo">235</span><a id="line.235">       * supersource for the entirety of {@link AbstractFuture}).</a>
+<span class="sourceLineNo">236</span><a id="line.236">       */</a>
+<span class="sourceLineNo">237</span><a id="line.237">      @Override</a>
+<span class="sourceLineNo">238</span><a id="line.238">      @J2ObjCIncompatible</a>
+<span class="sourceLineNo">239</span><a id="line.239">      @Nullable AtomicHelper tryMakeVarHandleAtomicHelper() {</a>
+<span class="sourceLineNo">240</span><a id="line.240">        try {</a>
+<span class="sourceLineNo">241</span><a id="line.241">          /*</a>
+<span class="sourceLineNo">242</span><a id="line.242">           * We first use reflection to check whether VarHandle exists. If we instead just tried to</a>
+<span class="sourceLineNo">243</span><a id="line.243">           * load our class directly (which would trigger non-reflective loading of VarHandle) from</a>
+<span class="sourceLineNo">244</span><a id="line.244">           * within a `try` block, then an error might be thrown even before we enter the `try`</a>
+<span class="sourceLineNo">245</span><a id="line.245">           * block: https://github.com/google/truth/issues/333#issuecomment-765652454</a>
+<span class="sourceLineNo">246</span><a id="line.246">           *</a>
+<span class="sourceLineNo">247</span><a id="line.247">           * Also, it's nice that this approach should let us catch *only* ClassNotFoundException</a>
+<span class="sourceLineNo">248</span><a id="line.248">           * instead of having to catch more broadly (potentially even including, say, a</a>
+<span class="sourceLineNo">249</span><a id="line.249">           * StackOverflowError).</a>
+<span class="sourceLineNo">250</span><a id="line.250">           */</a>
+<span class="sourceLineNo">251</span><a id="line.251">          Class.forName("java.lang.invoke.VarHandle");</a>
+<span class="sourceLineNo">252</span><a id="line.252">        } catch (ClassNotFoundException beforeJava9) {</a>
+<span class="sourceLineNo">253</span><a id="line.253">          return null;</a>
+<span class="sourceLineNo">254</span><a id="line.254">        }</a>
+<span class="sourceLineNo">255</span><a id="line.255">        return new VarHandleAtomicHelper();</a>
+<span class="sourceLineNo">256</span><a id="line.256">      }</a>
+<span class="sourceLineNo">257</span><a id="line.257">    };</a>
+<span class="sourceLineNo">258</span><a id="line.258"></a>
+<span class="sourceLineNo">259</span><a id="line.259">    /** Implementation used by J2ObjC environments, overridden for other environments. */</a>
+<span class="sourceLineNo">260</span><a id="line.260">    @Nullable AtomicHelper tryMakeVarHandleAtomicHelper() {</a>
+<span class="sourceLineNo">261</span><a id="line.261">      return null;</a>
+<span class="sourceLineNo">262</span><a id="line.262">    }</a>
+<span class="sourceLineNo">263</span><a id="line.263">  }</a>
+<span class="sourceLineNo">264</span><a id="line.264"></a>
+<span class="sourceLineNo">265</span><a id="line.265">  /** Waiter links form a Treiber stack, in the {@link #waiters} field. */</a>
+<span class="sourceLineNo">266</span><a id="line.266">  private static final class Waiter {</a>
+<span class="sourceLineNo">267</span><a id="line.267">    static final Waiter TOMBSTONE = new Waiter(false /* ignored param */);</a>
+<span class="sourceLineNo">268</span><a id="line.268"></a>
+<span class="sourceLineNo">269</span><a id="line.269">    volatile @Nullable Thread thread;</a>
+<span class="sourceLineNo">270</span><a id="line.270">    volatile @Nullable Waiter next;</a>
+<span class="sourceLineNo">271</span><a id="line.271"></a>
+<span class="sourceLineNo">272</span><a id="line.272">    /**</a>
+<span class="sourceLineNo">273</span><a id="line.273">     * Constructor for the TOMBSTONE, avoids use of ATOMIC_HELPER in case this class is loaded</a>
+<span class="sourceLineNo">274</span><a id="line.274">     * before the ATOMIC_HELPER. Apparently this is possible on some android platforms.</a>
+<span class="sourceLineNo">275</span><a id="line.275">     */</a>
+<span class="sourceLineNo">276</span><a id="line.276">    Waiter(boolean unused) {}</a>
 <span class="sourceLineNo">277</span><a id="line.277"></a>
-<span class="sourceLineNo">278</span><a id="line.278">  /** Listeners also form a stack through the {@link #listeners} field. */</a>
-<span class="sourceLineNo">279</span><a id="line.279">  private static final class Listener {</a>
-<span class="sourceLineNo">280</span><a id="line.280">    static final Listener TOMBSTONE = new Listener();</a>
-<span class="sourceLineNo">281</span><a id="line.281">    // null only for TOMBSTONE</a>
-<span class="sourceLineNo">282</span><a id="line.282">    final @Nullable Runnable task;</a>
-<span class="sourceLineNo">283</span><a id="line.283">    // null only for TOMBSTONE</a>
-<span class="sourceLineNo">284</span><a id="line.284">    final @Nullable Executor executor;</a>
-<span class="sourceLineNo">285</span><a id="line.285"></a>
-<span class="sourceLineNo">286</span><a id="line.286">    // writes to next are made visible by subsequent CAS's on the listeners field</a>
-<span class="sourceLineNo">287</span><a id="line.287">    @Nullable Listener next;</a>
+<span class="sourceLineNo">278</span><a id="line.278">    Waiter() {</a>
+<span class="sourceLineNo">279</span><a id="line.279">      // avoid volatile write, write is made visible by subsequent CAS on waiters field</a>
+<span class="sourceLineNo">280</span><a id="line.280">      ATOMIC_HELPER.putThread(this, Thread.currentThread());</a>
+<span class="sourceLineNo">281</span><a id="line.281">    }</a>
+<span class="sourceLineNo">282</span><a id="line.282"></a>
+<span class="sourceLineNo">283</span><a id="line.283">    // non-volatile write to the next field. Should be made visible by subsequent CAS on waiters</a>
+<span class="sourceLineNo">284</span><a id="line.284">    // field.</a>
+<span class="sourceLineNo">285</span><a id="line.285">    void setNext(@Nullable Waiter next) {</a>
+<span class="sourceLineNo">286</span><a id="line.286">      ATOMIC_HELPER.putNext(this, next);</a>
+<span class="sourceLineNo">287</span><a id="line.287">    }</a>
 <span class="sourceLineNo">288</span><a id="line.288"></a>
-<span class="sourceLineNo">289</span><a id="line.289">    Listener(Runnable task, Executor executor) {</a>
-<span class="sourceLineNo">290</span><a id="line.290">      this.task = task;</a>
-<span class="sourceLineNo">291</span><a id="line.291">      this.executor = executor;</a>
-<span class="sourceLineNo">292</span><a id="line.292">    }</a>
-<span class="sourceLineNo">293</span><a id="line.293"></a>
-<span class="sourceLineNo">294</span><a id="line.294">    Listener() {</a>
-<span class="sourceLineNo">295</span><a id="line.295">      this.task = null;</a>
-<span class="sourceLineNo">296</span><a id="line.296">      this.executor = null;</a>
-<span class="sourceLineNo">297</span><a id="line.297">    }</a>
-<span class="sourceLineNo">298</span><a id="line.298">  }</a>
-<span class="sourceLineNo">299</span><a id="line.299"></a>
-<span class="sourceLineNo">300</span><a id="line.300">  /** A special value to represent {@code null}. */</a>
-<span class="sourceLineNo">301</span><a id="line.301">  private static final Object NULL = new Object();</a>
-<span class="sourceLineNo">302</span><a id="line.302"></a>
-<span class="sourceLineNo">303</span><a id="line.303">  /** A special value to represent failure, when {@link #setException} is called successfully. */</a>
-<span class="sourceLineNo">304</span><a id="line.304">  private static final class Failure {</a>
-<span class="sourceLineNo">305</span><a id="line.305">    static final Failure FALLBACK_INSTANCE =</a>
-<span class="sourceLineNo">306</span><a id="line.306">        new Failure(</a>
-<span class="sourceLineNo">307</span><a id="line.307">            new Throwable("Failure occurred while trying to finish a future.") {</a>
-<span class="sourceLineNo">308</span><a id="line.308">              @Override</a>
-<span class="sourceLineNo">309</span><a id="line.309">              public synchronized Throwable fillInStackTrace() {</a>
-<span class="sourceLineNo">310</span><a id="line.310">                return this; // no stack trace</a>
-<span class="sourceLineNo">311</span><a id="line.311">              }</a>
-<span class="sourceLineNo">312</span><a id="line.312">            });</a>
-<span class="sourceLineNo">313</span><a id="line.313">    final Throwable exception;</a>
-<span class="sourceLineNo">314</span><a id="line.314"></a>
-<span class="sourceLineNo">315</span><a id="line.315">    Failure(Throwable exception) {</a>
-<span class="sourceLineNo">316</span><a id="line.316">      this.exception = checkNotNull(exception);</a>
-<span class="sourceLineNo">317</span><a id="line.317">    }</a>
-<span class="sourceLineNo">318</span><a id="line.318">  }</a>
-<span class="sourceLineNo">319</span><a id="line.319"></a>
-<span class="sourceLineNo">320</span><a id="line.320">  /** A special value to represent cancellation and the 'wasInterrupted' bit. */</a>
-<span class="sourceLineNo">321</span><a id="line.321">  private static final class Cancellation {</a>
-<span class="sourceLineNo">322</span><a id="line.322">    // constants to use when GENERATE_CANCELLATION_CAUSES = false</a>
-<span class="sourceLineNo">323</span><a id="line.323">    static final @Nullable Cancellation CAUSELESS_INTERRUPTED;</a>
-<span class="sourceLineNo">324</span><a id="line.324">    static final @Nullable Cancellation CAUSELESS_CANCELLED;</a>
-<span class="sourceLineNo">325</span><a id="line.325"></a>
-<span class="sourceLineNo">326</span><a id="line.326">    static {</a>
-<span class="sourceLineNo">327</span><a id="line.327">      if (GENERATE_CANCELLATION_CAUSES) {</a>
-<span class="sourceLineNo">328</span><a id="line.328">        CAUSELESS_CANCELLED = null;</a>
-<span class="sourceLineNo">329</span><a id="line.329">        CAUSELESS_INTERRUPTED = null;</a>
-<span class="sourceLineNo">330</span><a id="line.330">      } else {</a>
-<span class="sourceLineNo">331</span><a id="line.331">        CAUSELESS_CANCELLED = new Cancellation(false, null);</a>
-<span class="sourceLineNo">332</span><a id="line.332">        CAUSELESS_INTERRUPTED = new Cancellation(true, null);</a>
-<span class="sourceLineNo">333</span><a id="line.333">      }</a>
-<span class="sourceLineNo">334</span><a id="line.334">    }</a>
-<span class="sourceLineNo">335</span><a id="line.335"></a>
-<span class="sourceLineNo">336</span><a id="line.336">    final boolean wasInterrupted;</a>
-<span class="sourceLineNo">337</span><a id="line.337">    final @Nullable Throwable cause;</a>
-<span class="sourceLineNo">338</span><a id="line.338"></a>
-<span class="sourceLineNo">339</span><a id="line.339">    Cancellation(boolean wasInterrupted, @Nullable Throwable cause) {</a>
-<span class="sourceLineNo">340</span><a id="line.340">      this.wasInterrupted = wasInterrupted;</a>
-<span class="sourceLineNo">341</span><a id="line.341">      this.cause = cause;</a>
-<span class="sourceLineNo">342</span><a id="line.342">    }</a>
-<span class="sourceLineNo">343</span><a id="line.343">  }</a>
-<span class="sourceLineNo">344</span><a id="line.344"></a>
-<span class="sourceLineNo">345</span><a id="line.345">  /** A special value that encodes the 'setFuture' state. */</a>
-<span class="sourceLineNo">346</span><a id="line.346">  private static final class SetFuture&lt;V extends @Nullable Object&gt; implements Runnable {</a>
-<span class="sourceLineNo">347</span><a id="line.347">    final AbstractFuture&lt;V&gt; owner;</a>
-<span class="sourceLineNo">348</span><a id="line.348">    final ListenableFuture&lt;? extends V&gt; future;</a>
-<span class="sourceLineNo">349</span><a id="line.349"></a>
-<span class="sourceLineNo">350</span><a id="line.350">    SetFuture(AbstractFuture&lt;V&gt; owner, ListenableFuture&lt;? extends V&gt; future) {</a>
-<span class="sourceLineNo">351</span><a id="line.351">      this.owner = owner;</a>
-<span class="sourceLineNo">352</span><a id="line.352">      this.future = future;</a>
-<span class="sourceLineNo">353</span><a id="line.353">    }</a>
-<span class="sourceLineNo">354</span><a id="line.354"></a>
-<span class="sourceLineNo">355</span><a id="line.355">    @Override</a>
-<span class="sourceLineNo">356</span><a id="line.356">    public void run() {</a>
-<span class="sourceLineNo">357</span><a id="line.357">      if (owner.value != this) {</a>
-<span class="sourceLineNo">358</span><a id="line.358">        // nothing to do, we must have been cancelled, don't bother inspecting the future.</a>
-<span class="sourceLineNo">359</span><a id="line.359">        return;</a>
-<span class="sourceLineNo">360</span><a id="line.360">      }</a>
-<span class="sourceLineNo">361</span><a id="line.361">      Object valueToSet = getFutureValue(future);</a>
-<span class="sourceLineNo">362</span><a id="line.362">      if (ATOMIC_HELPER.casValue(owner, this, valueToSet)) {</a>
-<span class="sourceLineNo">363</span><a id="line.363">        complete(</a>
-<span class="sourceLineNo">364</span><a id="line.364">            owner,</a>
-<span class="sourceLineNo">365</span><a id="line.365">            /*</a>
-<span class="sourceLineNo">366</span><a id="line.366">             * Interruption doesn't propagate through a SetFuture chain (see getFutureValue), so</a>
-<span class="sourceLineNo">367</span><a id="line.367">             * don't invoke interruptTask.</a>
-<span class="sourceLineNo">368</span><a id="line.368">             */</a>
-<span class="sourceLineNo">369</span><a id="line.369">            false);</a>
-<span class="sourceLineNo">370</span><a id="line.370">      }</a>
-<span class="sourceLineNo">371</span><a id="line.371">    }</a>
-<span class="sourceLineNo">372</span><a id="line.372">  }</a>
-<span class="sourceLineNo">373</span><a id="line.373"></a>
-<span class="sourceLineNo">374</span><a id="line.374">  // TODO(lukes): investigate using the @Contended annotation on these fields when jdk8 is</a>
-<span class="sourceLineNo">375</span><a id="line.375">  // available.</a>
-<span class="sourceLineNo">376</span><a id="line.376">  /**</a>
-<span class="sourceLineNo">377</span><a id="line.377">   * This field encodes the current state of the future.</a>
-<span class="sourceLineNo">378</span><a id="line.378">   *</a>
-<span class="sourceLineNo">379</span><a id="line.379">   * &lt;p&gt;The valid values are:</a>
-<span class="sourceLineNo">380</span><a id="line.380">   *</a>
-<span class="sourceLineNo">381</span><a id="line.381">   * &lt;ul&gt;</a>
-<span class="sourceLineNo">382</span><a id="line.382">   *   &lt;li&gt;{@code null} initial state, nothing has happened.</a>
-<span class="sourceLineNo">383</span><a id="line.383">   *   &lt;li&gt;{@link Cancellation} terminal state, {@code cancel} was called.</a>
-<span class="sourceLineNo">384</span><a id="line.384">   *   &lt;li&gt;{@link Failure} terminal state, {@code setException} was called.</a>
-<span class="sourceLineNo">385</span><a id="line.385">   *   &lt;li&gt;{@link SetFuture} intermediate state, {@code setFuture} was called.</a>
-<span class="sourceLineNo">386</span><a id="line.386">   *   &lt;li&gt;{@link #NULL} terminal state, {@code set(null)} was called.</a>
-<span class="sourceLineNo">387</span><a id="line.387">   *   &lt;li&gt;Any other non-null value, terminal state, {@code set} was called with a non-null</a>
-<span class="sourceLineNo">388</span><a id="line.388">   *       argument.</a>
-<span class="sourceLineNo">389</span><a id="line.389">   * &lt;/ul&gt;</a>
-<span class="sourceLineNo">390</span><a id="line.390">   */</a>
-<span class="sourceLineNo">391</span><a id="line.391">  private volatile @Nullable Object value;</a>
-<span class="sourceLineNo">392</span><a id="line.392"></a>
-<span class="sourceLineNo">393</span><a id="line.393">  /** All listeners. */</a>
-<span class="sourceLineNo">394</span><a id="line.394">  private volatile @Nullable Listener listeners;</a>
-<span class="sourceLineNo">395</span><a id="line.395"></a>
-<span class="sourceLineNo">396</span><a id="line.396">  /** All waiting threads. */</a>
-<span class="sourceLineNo">397</span><a id="line.397">  private volatile @Nullable Waiter waiters;</a>
-<span class="sourceLineNo">398</span><a id="line.398"></a>
-<span class="sourceLineNo">399</span><a id="line.399">  /** Constructor for use by subclasses. */</a>
-<span class="sourceLineNo">400</span><a id="line.400">  protected AbstractFuture() {}</a>
-<span class="sourceLineNo">401</span><a id="line.401"></a>
-<span class="sourceLineNo">402</span><a id="line.402">  // Gets and Timed Gets</a>
-<span class="sourceLineNo">403</span><a id="line.403">  //</a>
-<span class="sourceLineNo">404</span><a id="line.404">  // * Be responsive to interruption</a>
-<span class="sourceLineNo">405</span><a id="line.405">  // * Don't create Waiter nodes if you aren't going to park, this helps reduce contention on the</a>
-<span class="sourceLineNo">406</span><a id="line.406">  //   waiters field.</a>
-<span class="sourceLineNo">407</span><a id="line.407">  // * Future completion is defined by when #value becomes non-null/non SetFuture</a>
-<span class="sourceLineNo">408</span><a id="line.408">  // * Future completion can be observed if the waiters field contains a TOMBSTONE</a>
-<span class="sourceLineNo">409</span><a id="line.409"></a>
-<span class="sourceLineNo">410</span><a id="line.410">  // Timed Get</a>
-<span class="sourceLineNo">411</span><a id="line.411">  // There are a few design constraints to consider</a>
-<span class="sourceLineNo">412</span><a id="line.412">  // * We want to be responsive to small timeouts, unpark() has non trivial latency overheads (I</a>
-<span class="sourceLineNo">413</span><a id="line.413">  //   have observed 12 micros on 64-bit linux systems to wake up a parked thread). So if the</a>
-<span class="sourceLineNo">414</span><a id="line.414">  //   timeout is small we shouldn't park(). This needs to be traded off with the cpu overhead of</a>
-<span class="sourceLineNo">415</span><a id="line.415">  //   spinning, so we use SPIN_THRESHOLD_NANOS which is what AbstractQueuedSynchronizer uses for</a>
-<span class="sourceLineNo">416</span><a id="line.416">  //   similar purposes.</a>
-<span class="sourceLineNo">417</span><a id="line.417">  // * We want to behave reasonably for timeouts of 0</a>
-<span class="sourceLineNo">418</span><a id="line.418">  // * We are more responsive to completion than timeouts. This is because parkNanos depends on</a>
-<span class="sourceLineNo">419</span><a id="line.419">  //   system scheduling and as such we could either miss our deadline, or unpark() could be delayed</a>
-<span class="sourceLineNo">420</span><a id="line.420">  //   so that it looks like we timed out even though we didn't. For comparison FutureTask respects</a>
-<span class="sourceLineNo">421</span><a id="line.421">  //   completion preferably and AQS is non-deterministic (depends on where in the queue the waiter</a>
-<span class="sourceLineNo">422</span><a id="line.422">  //   is). If we wanted to be strict about it, we could store the unpark() time in the Waiter node</a>
-<span class="sourceLineNo">423</span><a id="line.423">  //   and we could use that to make a decision about whether or not we timed out prior to being</a>
-<span class="sourceLineNo">424</span><a id="line.424">  //   unparked.</a>
-<span class="sourceLineNo">425</span><a id="line.425"></a>
-<span class="sourceLineNo">426</span><a id="line.426">  /**</a>
-<span class="sourceLineNo">427</span><a id="line.427">   * {@inheritDoc}</a>
-<span class="sourceLineNo">428</span><a id="line.428">   *</a>
-<span class="sourceLineNo">429</span><a id="line.429">   * &lt;p&gt;The default {@link AbstractFuture} implementation throws {@code InterruptedException} if the</a>
-<span class="sourceLineNo">430</span><a id="line.430">   * current thread is interrupted during the call, even if the value is already available.</a>
-<span class="sourceLineNo">431</span><a id="line.431">   *</a>
-<span class="sourceLineNo">432</span><a id="line.432">   * @throws CancellationException {@inheritDoc}</a>
-<span class="sourceLineNo">433</span><a id="line.433">   */</a>
-<span class="sourceLineNo">434</span><a id="line.434">  @SuppressWarnings("LabelledBreakTarget") // TODO(b/345814817): Maybe fix?</a>
-<span class="sourceLineNo">435</span><a id="line.435">  @CanIgnoreReturnValue</a>
-<span class="sourceLineNo">436</span><a id="line.436">  @Override</a>
-<span class="sourceLineNo">437</span><a id="line.437">  @ParametricNullness</a>
-<span class="sourceLineNo">438</span><a id="line.438">  public V get(long timeout, TimeUnit unit)</a>
-<span class="sourceLineNo">439</span><a id="line.439">      throws InterruptedException, TimeoutException, ExecutionException {</a>
-<span class="sourceLineNo">440</span><a id="line.440">    // NOTE: if timeout &lt; 0, remainingNanos will be &lt; 0 and we will fall into the while(true) loop</a>
-<span class="sourceLineNo">441</span><a id="line.441">    // at the bottom and throw a timeoutexception.</a>
-<span class="sourceLineNo">442</span><a id="line.442">    final long timeoutNanos = unit.toNanos(timeout); // we rely on the implicit null check on unit.</a>
-<span class="sourceLineNo">443</span><a id="line.443">    long remainingNanos = timeoutNanos;</a>
-<span class="sourceLineNo">444</span><a id="line.444">    if (Thread.interrupted()) {</a>
-<span class="sourceLineNo">445</span><a id="line.445">      throw new InterruptedException();</a>
-<span class="sourceLineNo">446</span><a id="line.446">    }</a>
-<span class="sourceLineNo">447</span><a id="line.447">    @RetainedLocalRef Object localValue = value;</a>
-<span class="sourceLineNo">448</span><a id="line.448">    if (localValue != null &amp; !(localValue instanceof SetFuture)) {</a>
-<span class="sourceLineNo">449</span><a id="line.449">      return getDoneValue(localValue);</a>
-<span class="sourceLineNo">450</span><a id="line.450">    }</a>
-<span class="sourceLineNo">451</span><a id="line.451">    // we delay calling nanoTime until we know we will need to either park or spin</a>
-<span class="sourceLineNo">452</span><a id="line.452">    final long endNanos = remainingNanos &gt; 0 ? System.nanoTime() + remainingNanos : 0;</a>
-<span class="sourceLineNo">453</span><a id="line.453">    long_wait_loop:</a>
-<span class="sourceLineNo">454</span><a id="line.454">    if (remainingNanos &gt;= SPIN_THRESHOLD_NANOS) {</a>
-<span class="sourceLineNo">455</span><a id="line.455">      Waiter oldHead = waiters;</a>
-<span class="sourceLineNo">456</span><a id="line.456">      if (oldHead != Waiter.TOMBSTONE) {</a>
-<span class="sourceLineNo">457</span><a id="line.457">        Waiter node = new Waiter();</a>
-<span class="sourceLineNo">458</span><a id="line.458">        do {</a>
-<span class="sourceLineNo">459</span><a id="line.459">          node.setNext(oldHead);</a>
-<span class="sourceLineNo">460</span><a id="line.460">          if (ATOMIC_HELPER.casWaiters(this, oldHead, node)) {</a>
-<span class="sourceLineNo">461</span><a id="line.461">            while (true) {</a>
-<span class="sourceLineNo">462</span><a id="line.462">              OverflowAvoidingLockSupport.parkNanos(this, remainingNanos);</a>
-<span class="sourceLineNo">463</span><a id="line.463">              // Check interruption first, if we woke up due to interruption we need to honor that.</a>
-<span class="sourceLineNo">464</span><a id="line.464">              if (Thread.interrupted()) {</a>
-<span class="sourceLineNo">465</span><a id="line.465">                removeWaiter(node);</a>
-<span class="sourceLineNo">466</span><a id="line.466">                throw new InterruptedException();</a>
-<span class="sourceLineNo">467</span><a id="line.467">              }</a>
-<span class="sourceLineNo">468</span><a id="line.468"></a>
-<span class="sourceLineNo">469</span><a id="line.469">              // Otherwise re-read and check doneness. If we loop then it must have been a spurious</a>
-<span class="sourceLineNo">470</span><a id="line.470">              // wakeup</a>
-<span class="sourceLineNo">471</span><a id="line.471">              localValue = value;</a>
-<span class="sourceLineNo">472</span><a id="line.472">              if (localValue != null &amp; !(localValue instanceof SetFuture)) {</a>
-<span class="sourceLineNo">473</span><a id="line.473">                return getDoneValue(localValue);</a>
-<span class="sourceLineNo">474</span><a id="line.474">              }</a>
-<span class="sourceLineNo">475</span><a id="line.475"></a>
-<span class="sourceLineNo">476</span><a id="line.476">              // timed out?</a>
-<span class="sourceLineNo">477</span><a id="line.477">              remainingNanos = endNanos - System.nanoTime();</a>
-<span class="sourceLineNo">478</span><a id="line.478">              if (remainingNanos &lt; SPIN_THRESHOLD_NANOS) {</a>
-<span class="sourceLineNo">479</span><a id="line.479">                // Remove the waiter, one way or another we are done parking this thread.</a>
-<span class="sourceLineNo">480</span><a id="line.480">                removeWaiter(node);</a>
-<span class="sourceLineNo">481</span><a id="line.481">                break long_wait_loop; // jump down to the busy wait loop</a>
-<span class="sourceLineNo">482</span><a id="line.482">              }</a>
-<span class="sourceLineNo">483</span><a id="line.483">            }</a>
-<span class="sourceLineNo">484</span><a id="line.484">          }</a>
-<span class="sourceLineNo">485</span><a id="line.485">          oldHead = waiters; // re-read and loop.</a>
-<span class="sourceLineNo">486</span><a id="line.486">        } while (oldHead != Waiter.TOMBSTONE);</a>
-<span class="sourceLineNo">487</span><a id="line.487">      }</a>
-<span class="sourceLineNo">488</span><a id="line.488">      // re-read value, if we get here then we must have observed a TOMBSTONE while trying to add a</a>
-<span class="sourceLineNo">489</span><a id="line.489">      // waiter.</a>
-<span class="sourceLineNo">490</span><a id="line.490">      // requireNonNull is safe because value is always set before TOMBSTONE.</a>
-<span class="sourceLineNo">491</span><a id="line.491">      return getDoneValue(requireNonNull(value));</a>
-<span class="sourceLineNo">492</span><a id="line.492">    }</a>
-<span class="sourceLineNo">493</span><a id="line.493">    // If we get here then we have remainingNanos &lt; SPIN_THRESHOLD_NANOS and there is no node on the</a>
-<span class="sourceLineNo">494</span><a id="line.494">    // waiters list</a>
-<span class="sourceLineNo">495</span><a id="line.495">    while (remainingNanos &gt; 0) {</a>
-<span class="sourceLineNo">496</span><a id="line.496">      localValue = value;</a>
-<span class="sourceLineNo">497</span><a id="line.497">      if (localValue != null &amp; !(localValue instanceof SetFuture)) {</a>
-<span class="sourceLineNo">498</span><a id="line.498">        return getDoneValue(localValue);</a>
-<span class="sourceLineNo">499</span><a id="line.499">      }</a>
-<span class="sourceLineNo">500</span><a id="line.500">      if (Thread.interrupted()) {</a>
-<span class="sourceLineNo">501</span><a id="line.501">        throw new InterruptedException();</a>
-<span class="sourceLineNo">502</span><a id="line.502">      }</a>
-<span class="sourceLineNo">503</span><a id="line.503">      remainingNanos = endNanos - System.nanoTime();</a>
-<span class="sourceLineNo">504</span><a id="line.504">    }</a>
-<span class="sourceLineNo">505</span><a id="line.505"></a>
-<span class="sourceLineNo">506</span><a id="line.506">    String futureToString = toString();</a>
-<span class="sourceLineNo">507</span><a id="line.507">    final String unitString = unit.toString().toLowerCase(Locale.ROOT);</a>
-<span class="sourceLineNo">508</span><a id="line.508">    String message = "Waited " + timeout + " " + unit.toString().toLowerCase(Locale.ROOT);</a>
-<span class="sourceLineNo">509</span><a id="line.509">    // Only report scheduling delay if larger than our spin threshold - otherwise it's just noise</a>
-<span class="sourceLineNo">510</span><a id="line.510">    if (remainingNanos + SPIN_THRESHOLD_NANOS &lt; 0) {</a>
-<span class="sourceLineNo">511</span><a id="line.511">      // We over-waited for our timeout.</a>
-<span class="sourceLineNo">512</span><a id="line.512">      message += " (plus ";</a>
-<span class="sourceLineNo">513</span><a id="line.513">      long overWaitNanos = -remainingNanos;</a>
-<span class="sourceLineNo">514</span><a id="line.514">      long overWaitUnits = unit.convert(overWaitNanos, NANOSECONDS);</a>
-<span class="sourceLineNo">515</span><a id="line.515">      long overWaitLeftoverNanos = overWaitNanos - unit.toNanos(overWaitUnits);</a>
-<span class="sourceLineNo">516</span><a id="line.516">      boolean shouldShowExtraNanos =</a>
-<span class="sourceLineNo">517</span><a id="line.517">          overWaitUnits == 0 || overWaitLeftoverNanos &gt; SPIN_THRESHOLD_NANOS;</a>
-<span class="sourceLineNo">518</span><a id="line.518">      if (overWaitUnits &gt; 0) {</a>
-<span class="sourceLineNo">519</span><a id="line.519">        message += overWaitUnits + " " + unitString;</a>
-<span class="sourceLineNo">520</span><a id="line.520">        if (shouldShowExtraNanos) {</a>
-<span class="sourceLineNo">521</span><a id="line.521">          message += ",";</a>
-<span class="sourceLineNo">522</span><a id="line.522">        }</a>
-<span class="sourceLineNo">523</span><a id="line.523">        message += " ";</a>
-<span class="sourceLineNo">524</span><a id="line.524">      }</a>
-<span class="sourceLineNo">525</span><a id="line.525">      if (shouldShowExtraNanos) {</a>
-<span class="sourceLineNo">526</span><a id="line.526">        message += overWaitLeftoverNanos + " nanoseconds ";</a>
-<span class="sourceLineNo">527</span><a id="line.527">      }</a>
-<span class="sourceLineNo">528</span><a id="line.528"></a>
-<span class="sourceLineNo">529</span><a id="line.529">      message += "delay)";</a>
-<span class="sourceLineNo">530</span><a id="line.530">    }</a>
-<span class="sourceLineNo">531</span><a id="line.531">    // It's confusing to see a completed future in a timeout message; if isDone() returns false,</a>
-<span class="sourceLineNo">532</span><a id="line.532">    // then we know it must have given a pending toString value earlier. If not, then the future</a>
-<span class="sourceLineNo">533</span><a id="line.533">    // completed after the timeout expired, and the message might be success.</a>
-<span class="sourceLineNo">534</span><a id="line.534">    if (isDone()) {</a>
-<span class="sourceLineNo">535</span><a id="line.535">      throw new TimeoutException(message + " but future completed as timeout expired");</a>
-<span class="sourceLineNo">536</span><a id="line.536">    }</a>
-<span class="sourceLineNo">537</span><a id="line.537">    throw new TimeoutException(message + " for " + futureToString);</a>
-<span class="sourceLineNo">538</span><a id="line.538">  }</a>
-<span class="sourceLineNo">539</span><a id="line.539"></a>
-<span class="sourceLineNo">540</span><a id="line.540">  /**</a>
-<span class="sourceLineNo">541</span><a id="line.541">   * {@inheritDoc}</a>
-<span class="sourceLineNo">542</span><a id="line.542">   *</a>
-<span class="sourceLineNo">543</span><a id="line.543">   * &lt;p&gt;The default {@link AbstractFuture} implementation throws {@code InterruptedException} if the</a>
-<span class="sourceLineNo">544</span><a id="line.544">   * current thread is interrupted during the call, even if the value is already available.</a>
-<span class="sourceLineNo">545</span><a id="line.545">   *</a>
-<span class="sourceLineNo">546</span><a id="line.546">   * @throws CancellationException {@inheritDoc}</a>
-<span class="sourceLineNo">547</span><a id="line.547">   */</a>
-<span class="sourceLineNo">548</span><a id="line.548">  @CanIgnoreReturnValue</a>
-<span class="sourceLineNo">549</span><a id="line.549">  @Override</a>
-<span class="sourceLineNo">550</span><a id="line.550">  @ParametricNullness</a>
-<span class="sourceLineNo">551</span><a id="line.551">  public V get() throws InterruptedException, ExecutionException {</a>
-<span class="sourceLineNo">552</span><a id="line.552">    if (Thread.interrupted()) {</a>
-<span class="sourceLineNo">553</span><a id="line.553">      throw new InterruptedException();</a>
+<span class="sourceLineNo">289</span><a id="line.289">    void unpark() {</a>
+<span class="sourceLineNo">290</span><a id="line.290">      // This is racy with removeWaiter. The consequence of the race is that we may spuriously call</a>
+<span class="sourceLineNo">291</span><a id="line.291">      // unpark even though the thread has already removed itself from the list. But even if we did</a>
+<span class="sourceLineNo">292</span><a id="line.292">      // use a CAS, that race would still exist (it would just be ever so slightly smaller).</a>
+<span class="sourceLineNo">293</span><a id="line.293">      Thread w = thread;</a>
+<span class="sourceLineNo">294</span><a id="line.294">      if (w != null) {</a>
+<span class="sourceLineNo">295</span><a id="line.295">        thread = null;</a>
+<span class="sourceLineNo">296</span><a id="line.296">        LockSupport.unpark(w);</a>
+<span class="sourceLineNo">297</span><a id="line.297">      }</a>
+<span class="sourceLineNo">298</span><a id="line.298">    }</a>
+<span class="sourceLineNo">299</span><a id="line.299">  }</a>
+<span class="sourceLineNo">300</span><a id="line.300"></a>
+<span class="sourceLineNo">301</span><a id="line.301">  /**</a>
+<span class="sourceLineNo">302</span><a id="line.302">   * Marks the given node as 'deleted' (null waiter) and then scans the list to unlink all deleted</a>
+<span class="sourceLineNo">303</span><a id="line.303">   * nodes. This is an O(n) operation in the common case (and O(n^2) in the worst), but we are saved</a>
+<span class="sourceLineNo">304</span><a id="line.304">   * by two things.</a>
+<span class="sourceLineNo">305</span><a id="line.305">   *</a>
+<span class="sourceLineNo">306</span><a id="line.306">   * &lt;ul&gt;</a>
+<span class="sourceLineNo">307</span><a id="line.307">   *   &lt;li&gt;This is only called when a waiting thread times out or is interrupted. Both of which</a>
+<span class="sourceLineNo">308</span><a id="line.308">   *       should be rare.</a>
+<span class="sourceLineNo">309</span><a id="line.309">   *   &lt;li&gt;The waiters list should be very short.</a>
+<span class="sourceLineNo">310</span><a id="line.310">   * &lt;/ul&gt;</a>
+<span class="sourceLineNo">311</span><a id="line.311">   */</a>
+<span class="sourceLineNo">312</span><a id="line.312">  private void removeWaiter(Waiter node) {</a>
+<span class="sourceLineNo">313</span><a id="line.313">    node.thread = null; // mark as 'deleted'</a>
+<span class="sourceLineNo">314</span><a id="line.314">    restart:</a>
+<span class="sourceLineNo">315</span><a id="line.315">    while (true) {</a>
+<span class="sourceLineNo">316</span><a id="line.316">      Waiter pred = null;</a>
+<span class="sourceLineNo">317</span><a id="line.317">      Waiter curr = waiters;</a>
+<span class="sourceLineNo">318</span><a id="line.318">      if (curr == Waiter.TOMBSTONE) {</a>
+<span class="sourceLineNo">319</span><a id="line.319">        return; // give up if someone is calling complete</a>
+<span class="sourceLineNo">320</span><a id="line.320">      }</a>
+<span class="sourceLineNo">321</span><a id="line.321">      Waiter succ;</a>
+<span class="sourceLineNo">322</span><a id="line.322">      while (curr != null) {</a>
+<span class="sourceLineNo">323</span><a id="line.323">        succ = curr.next;</a>
+<span class="sourceLineNo">324</span><a id="line.324">        if (curr.thread != null) { // we aren't unlinking this node, update pred.</a>
+<span class="sourceLineNo">325</span><a id="line.325">          pred = curr;</a>
+<span class="sourceLineNo">326</span><a id="line.326">        } else if (pred != null) { // We are unlinking this node and it has a predecessor.</a>
+<span class="sourceLineNo">327</span><a id="line.327">          pred.next = succ;</a>
+<span class="sourceLineNo">328</span><a id="line.328">          if (pred.thread == null) { // We raced with another node that unlinked pred. Restart.</a>
+<span class="sourceLineNo">329</span><a id="line.329">            continue restart;</a>
+<span class="sourceLineNo">330</span><a id="line.330">          }</a>
+<span class="sourceLineNo">331</span><a id="line.331">        } else if (!ATOMIC_HELPER.casWaiters(this, curr, succ)) { // We are unlinking head</a>
+<span class="sourceLineNo">332</span><a id="line.332">          continue restart; // We raced with an add or complete</a>
+<span class="sourceLineNo">333</span><a id="line.333">        }</a>
+<span class="sourceLineNo">334</span><a id="line.334">        curr = succ;</a>
+<span class="sourceLineNo">335</span><a id="line.335">      }</a>
+<span class="sourceLineNo">336</span><a id="line.336">      break;</a>
+<span class="sourceLineNo">337</span><a id="line.337">    }</a>
+<span class="sourceLineNo">338</span><a id="line.338">  }</a>
+<span class="sourceLineNo">339</span><a id="line.339"></a>
+<span class="sourceLineNo">340</span><a id="line.340">  /** Listeners also form a stack through the {@link #listeners} field. */</a>
+<span class="sourceLineNo">341</span><a id="line.341">  private static final class Listener {</a>
+<span class="sourceLineNo">342</span><a id="line.342">    static final Listener TOMBSTONE = new Listener();</a>
+<span class="sourceLineNo">343</span><a id="line.343">    // null only for TOMBSTONE</a>
+<span class="sourceLineNo">344</span><a id="line.344">    final @Nullable Runnable task;</a>
+<span class="sourceLineNo">345</span><a id="line.345">    // null only for TOMBSTONE</a>
+<span class="sourceLineNo">346</span><a id="line.346">    final @Nullable Executor executor;</a>
+<span class="sourceLineNo">347</span><a id="line.347"></a>
+<span class="sourceLineNo">348</span><a id="line.348">    // writes to next are made visible by subsequent CAS's on the listeners field</a>
+<span class="sourceLineNo">349</span><a id="line.349">    @Nullable Listener next;</a>
+<span class="sourceLineNo">350</span><a id="line.350"></a>
+<span class="sourceLineNo">351</span><a id="line.351">    Listener(Runnable task, Executor executor) {</a>
+<span class="sourceLineNo">352</span><a id="line.352">      this.task = task;</a>
+<span class="sourceLineNo">353</span><a id="line.353">      this.executor = executor;</a>
+<span class="sourceLineNo">354</span><a id="line.354">    }</a>
+<span class="sourceLineNo">355</span><a id="line.355"></a>
+<span class="sourceLineNo">356</span><a id="line.356">    Listener() {</a>
+<span class="sourceLineNo">357</span><a id="line.357">      this.task = null;</a>
+<span class="sourceLineNo">358</span><a id="line.358">      this.executor = null;</a>
+<span class="sourceLineNo">359</span><a id="line.359">    }</a>
+<span class="sourceLineNo">360</span><a id="line.360">  }</a>
+<span class="sourceLineNo">361</span><a id="line.361"></a>
+<span class="sourceLineNo">362</span><a id="line.362">  /** A special value to represent {@code null}. */</a>
+<span class="sourceLineNo">363</span><a id="line.363">  private static final Object NULL = new Object();</a>
+<span class="sourceLineNo">364</span><a id="line.364"></a>
+<span class="sourceLineNo">365</span><a id="line.365">  /** A special value to represent failure, when {@link #setException} is called successfully. */</a>
+<span class="sourceLineNo">366</span><a id="line.366">  private static final class Failure {</a>
+<span class="sourceLineNo">367</span><a id="line.367">    static final Failure FALLBACK_INSTANCE =</a>
+<span class="sourceLineNo">368</span><a id="line.368">        new Failure(</a>
+<span class="sourceLineNo">369</span><a id="line.369">            new Throwable("Failure occurred while trying to finish a future.") {</a>
+<span class="sourceLineNo">370</span><a id="line.370">              @Override</a>
+<span class="sourceLineNo">371</span><a id="line.371">              public synchronized Throwable fillInStackTrace() {</a>
+<span class="sourceLineNo">372</span><a id="line.372">                return this; // no stack trace</a>
+<span class="sourceLineNo">373</span><a id="line.373">              }</a>
+<span class="sourceLineNo">374</span><a id="line.374">            });</a>
+<span class="sourceLineNo">375</span><a id="line.375">    final Throwable exception;</a>
+<span class="sourceLineNo">376</span><a id="line.376"></a>
+<span class="sourceLineNo">377</span><a id="line.377">    Failure(Throwable exception) {</a>
+<span class="sourceLineNo">378</span><a id="line.378">      this.exception = checkNotNull(exception);</a>
+<span class="sourceLineNo">379</span><a id="line.379">    }</a>
+<span class="sourceLineNo">380</span><a id="line.380">  }</a>
+<span class="sourceLineNo">381</span><a id="line.381"></a>
+<span class="sourceLineNo">382</span><a id="line.382">  /** A special value to represent cancellation and the 'wasInterrupted' bit. */</a>
+<span class="sourceLineNo">383</span><a id="line.383">  private static final class Cancellation {</a>
+<span class="sourceLineNo">384</span><a id="line.384">    // constants to use when GENERATE_CANCELLATION_CAUSES = false</a>
+<span class="sourceLineNo">385</span><a id="line.385">    static final @Nullable Cancellation CAUSELESS_INTERRUPTED;</a>
+<span class="sourceLineNo">386</span><a id="line.386">    static final @Nullable Cancellation CAUSELESS_CANCELLED;</a>
+<span class="sourceLineNo">387</span><a id="line.387"></a>
+<span class="sourceLineNo">388</span><a id="line.388">    static {</a>
+<span class="sourceLineNo">389</span><a id="line.389">      if (GENERATE_CANCELLATION_CAUSES) {</a>
+<span class="sourceLineNo">390</span><a id="line.390">        CAUSELESS_CANCELLED = null;</a>
+<span class="sourceLineNo">391</span><a id="line.391">        CAUSELESS_INTERRUPTED = null;</a>
+<span class="sourceLineNo">392</span><a id="line.392">      } else {</a>
+<span class="sourceLineNo">393</span><a id="line.393">        CAUSELESS_CANCELLED = new Cancellation(false, null);</a>
+<span class="sourceLineNo">394</span><a id="line.394">        CAUSELESS_INTERRUPTED = new Cancellation(true, null);</a>
+<span class="sourceLineNo">395</span><a id="line.395">      }</a>
+<span class="sourceLineNo">396</span><a id="line.396">    }</a>
+<span class="sourceLineNo">397</span><a id="line.397"></a>
+<span class="sourceLineNo">398</span><a id="line.398">    final boolean wasInterrupted;</a>
+<span class="sourceLineNo">399</span><a id="line.399">    final @Nullable Throwable cause;</a>
+<span class="sourceLineNo">400</span><a id="line.400"></a>
+<span class="sourceLineNo">401</span><a id="line.401">    Cancellation(boolean wasInterrupted, @Nullable Throwable cause) {</a>
+<span class="sourceLineNo">402</span><a id="line.402">      this.wasInterrupted = wasInterrupted;</a>
+<span class="sourceLineNo">403</span><a id="line.403">      this.cause = cause;</a>
+<span class="sourceLineNo">404</span><a id="line.404">    }</a>
+<span class="sourceLineNo">405</span><a id="line.405">  }</a>
+<span class="sourceLineNo">406</span><a id="line.406"></a>
+<span class="sourceLineNo">407</span><a id="line.407">  /** A special value that encodes the 'setFuture' state. */</a>
+<span class="sourceLineNo">408</span><a id="line.408">  private static final class SetFuture&lt;V extends @Nullable Object&gt; implements Runnable {</a>
+<span class="sourceLineNo">409</span><a id="line.409">    final AbstractFuture&lt;V&gt; owner;</a>
+<span class="sourceLineNo">410</span><a id="line.410">    final ListenableFuture&lt;? extends V&gt; future;</a>
+<span class="sourceLineNo">411</span><a id="line.411"></a>
+<span class="sourceLineNo">412</span><a id="line.412">    SetFuture(AbstractFuture&lt;V&gt; owner, ListenableFuture&lt;? extends V&gt; future) {</a>
+<span class="sourceLineNo">413</span><a id="line.413">      this.owner = owner;</a>
+<span class="sourceLineNo">414</span><a id="line.414">      this.future = future;</a>
+<span class="sourceLineNo">415</span><a id="line.415">    }</a>
+<span class="sourceLineNo">416</span><a id="line.416"></a>
+<span class="sourceLineNo">417</span><a id="line.417">    @Override</a>
+<span class="sourceLineNo">418</span><a id="line.418">    public void run() {</a>
+<span class="sourceLineNo">419</span><a id="line.419">      if (owner.value != this) {</a>
+<span class="sourceLineNo">420</span><a id="line.420">        // nothing to do, we must have been cancelled, don't bother inspecting the future.</a>
+<span class="sourceLineNo">421</span><a id="line.421">        return;</a>
+<span class="sourceLineNo">422</span><a id="line.422">      }</a>
+<span class="sourceLineNo">423</span><a id="line.423">      Object valueToSet = getFutureValue(future);</a>
+<span class="sourceLineNo">424</span><a id="line.424">      if (ATOMIC_HELPER.casValue(owner, this, valueToSet)) {</a>
+<span class="sourceLineNo">425</span><a id="line.425">        complete(</a>
+<span class="sourceLineNo">426</span><a id="line.426">            owner,</a>
+<span class="sourceLineNo">427</span><a id="line.427">            /*</a>
+<span class="sourceLineNo">428</span><a id="line.428">             * Interruption doesn't propagate through a SetFuture chain (see getFutureValue), so</a>
+<span class="sourceLineNo">429</span><a id="line.429">             * don't invoke interruptTask.</a>
+<span class="sourceLineNo">430</span><a id="line.430">             */</a>
+<span class="sourceLineNo">431</span><a id="line.431">            false);</a>
+<span class="sourceLineNo">432</span><a id="line.432">      }</a>
+<span class="sourceLineNo">433</span><a id="line.433">    }</a>
+<span class="sourceLineNo">434</span><a id="line.434">  }</a>
+<span class="sourceLineNo">435</span><a id="line.435"></a>
+<span class="sourceLineNo">436</span><a id="line.436">  // TODO(lukes): investigate using the @Contended annotation on these fields when jdk8 is</a>
+<span class="sourceLineNo">437</span><a id="line.437">  // available.</a>
+<span class="sourceLineNo">438</span><a id="line.438">  /**</a>
+<span class="sourceLineNo">439</span><a id="line.439">   * This field encodes the current state of the future.</a>
+<span class="sourceLineNo">440</span><a id="line.440">   *</a>
+<span class="sourceLineNo">441</span><a id="line.441">   * &lt;p&gt;The valid values are:</a>
+<span class="sourceLineNo">442</span><a id="line.442">   *</a>
+<span class="sourceLineNo">443</span><a id="line.443">   * &lt;ul&gt;</a>
+<span class="sourceLineNo">444</span><a id="line.444">   *   &lt;li&gt;{@code null} initial state, nothing has happened.</a>
+<span class="sourceLineNo">445</span><a id="line.445">   *   &lt;li&gt;{@link Cancellation} terminal state, {@code cancel} was called.</a>
+<span class="sourceLineNo">446</span><a id="line.446">   *   &lt;li&gt;{@link Failure} terminal state, {@code setException} was called.</a>
+<span class="sourceLineNo">447</span><a id="line.447">   *   &lt;li&gt;{@link SetFuture} intermediate state, {@code setFuture} was called.</a>
+<span class="sourceLineNo">448</span><a id="line.448">   *   &lt;li&gt;{@link #NULL} terminal state, {@code set(null)} was called.</a>
+<span class="sourceLineNo">449</span><a id="line.449">   *   &lt;li&gt;Any other non-null value, terminal state, {@code set} was called with a non-null</a>
+<span class="sourceLineNo">450</span><a id="line.450">   *       argument.</a>
+<span class="sourceLineNo">451</span><a id="line.451">   * &lt;/ul&gt;</a>
+<span class="sourceLineNo">452</span><a id="line.452">   */</a>
+<span class="sourceLineNo">453</span><a id="line.453">  private volatile @Nullable Object value;</a>
+<span class="sourceLineNo">454</span><a id="line.454"></a>
+<span class="sourceLineNo">455</span><a id="line.455">  /** All listeners. */</a>
+<span class="sourceLineNo">456</span><a id="line.456">  private volatile @Nullable Listener listeners;</a>
+<span class="sourceLineNo">457</span><a id="line.457"></a>
+<span class="sourceLineNo">458</span><a id="line.458">  /** All waiting threads. */</a>
+<span class="sourceLineNo">459</span><a id="line.459">  private volatile @Nullable Waiter waiters;</a>
+<span class="sourceLineNo">460</span><a id="line.460"></a>
+<span class="sourceLineNo">461</span><a id="line.461">  /** Constructor for use by subclasses. */</a>
+<span class="sourceLineNo">462</span><a id="line.462">  protected AbstractFuture() {}</a>
+<span class="sourceLineNo">463</span><a id="line.463"></a>
+<span class="sourceLineNo">464</span><a id="line.464">  // Gets and Timed Gets</a>
+<span class="sourceLineNo">465</span><a id="line.465">  //</a>
+<span class="sourceLineNo">466</span><a id="line.466">  // * Be responsive to interruption</a>
+<span class="sourceLineNo">467</span><a id="line.467">  // * Don't create Waiter nodes if you aren't going to park, this helps reduce contention on the</a>
+<span class="sourceLineNo">468</span><a id="line.468">  //   waiters field.</a>
+<span class="sourceLineNo">469</span><a id="line.469">  // * Future completion is defined by when #value becomes non-null/non SetFuture</a>
+<span class="sourceLineNo">470</span><a id="line.470">  // * Future completion can be observed if the waiters field contains a TOMBSTONE</a>
+<span class="sourceLineNo">471</span><a id="line.471"></a>
+<span class="sourceLineNo">472</span><a id="line.472">  // Timed Get</a>
+<span class="sourceLineNo">473</span><a id="line.473">  // There are a few design constraints to consider</a>
+<span class="sourceLineNo">474</span><a id="line.474">  // * We want to be responsive to small timeouts, unpark() has non trivial latency overheads (I</a>
+<span class="sourceLineNo">475</span><a id="line.475">  //   have observed 12 micros on 64-bit linux systems to wake up a parked thread). So if the</a>
+<span class="sourceLineNo">476</span><a id="line.476">  //   timeout is small we shouldn't park(). This needs to be traded off with the cpu overhead of</a>
+<span class="sourceLineNo">477</span><a id="line.477">  //   spinning, so we use SPIN_THRESHOLD_NANOS which is what AbstractQueuedSynchronizer uses for</a>
+<span class="sourceLineNo">478</span><a id="line.478">  //   similar purposes.</a>
+<span class="sourceLineNo">479</span><a id="line.479">  // * We want to behave reasonably for timeouts of 0</a>
+<span class="sourceLineNo">480</span><a id="line.480">  // * We are more responsive to completion than timeouts. This is because parkNanos depends on</a>
+<span class="sourceLineNo">481</span><a id="line.481">  //   system scheduling and as such we could either miss our deadline, or unpark() could be delayed</a>
+<span class="sourceLineNo">482</span><a id="line.482">  //   so that it looks like we timed out even though we didn't. For comparison FutureTask respects</a>
+<span class="sourceLineNo">483</span><a id="line.483">  //   completion preferably and AQS is non-deterministic (depends on where in the queue the waiter</a>
+<span class="sourceLineNo">484</span><a id="line.484">  //   is). If we wanted to be strict about it, we could store the unpark() time in the Waiter node</a>
+<span class="sourceLineNo">485</span><a id="line.485">  //   and we could use that to make a decision about whether or not we timed out prior to being</a>
+<span class="sourceLineNo">486</span><a id="line.486">  //   unparked.</a>
+<span class="sourceLineNo">487</span><a id="line.487"></a>
+<span class="sourceLineNo">488</span><a id="line.488">  /**</a>
+<span class="sourceLineNo">489</span><a id="line.489">   * {@inheritDoc}</a>
+<span class="sourceLineNo">490</span><a id="line.490">   *</a>
+<span class="sourceLineNo">491</span><a id="line.491">   * &lt;p&gt;The default {@link AbstractFuture} implementation throws {@code InterruptedException} if the</a>
+<span class="sourceLineNo">492</span><a id="line.492">   * current thread is interrupted during the call, even if the value is already available.</a>
+<span class="sourceLineNo">493</span><a id="line.493">   *</a>
+<span class="sourceLineNo">494</span><a id="line.494">   * @throws CancellationException {@inheritDoc}</a>
+<span class="sourceLineNo">495</span><a id="line.495">   */</a>
+<span class="sourceLineNo">496</span><a id="line.496">  @SuppressWarnings("LabelledBreakTarget") // TODO(b/345814817): Maybe fix?</a>
+<span class="sourceLineNo">497</span><a id="line.497">  @CanIgnoreReturnValue</a>
+<span class="sourceLineNo">498</span><a id="line.498">  @Override</a>
+<span class="sourceLineNo">499</span><a id="line.499">  @ParametricNullness</a>
+<span class="sourceLineNo">500</span><a id="line.500">  public V get(long timeout, TimeUnit unit)</a>
+<span class="sourceLineNo">501</span><a id="line.501">      throws InterruptedException, TimeoutException, ExecutionException {</a>
+<span class="sourceLineNo">502</span><a id="line.502">    // NOTE: if timeout &lt; 0, remainingNanos will be &lt; 0 and we will fall into the while(true) loop</a>
+<span class="sourceLineNo">503</span><a id="line.503">    // at the bottom and throw a timeoutexception.</a>
+<span class="sourceLineNo">504</span><a id="line.504">    final long timeoutNanos = unit.toNanos(timeout); // we rely on the implicit null check on unit.</a>
+<span class="sourceLineNo">505</span><a id="line.505">    long remainingNanos = timeoutNanos;</a>
+<span class="sourceLineNo">506</span><a id="line.506">    if (Thread.interrupted()) {</a>
+<span class="sourceLineNo">507</span><a id="line.507">      throw new InterruptedException();</a>
+<span class="sourceLineNo">508</span><a id="line.508">    }</a>
+<span class="sourceLineNo">509</span><a id="line.509">    @RetainedLocalRef Object localValue = value;</a>
+<span class="sourceLineNo">510</span><a id="line.510">    if (localValue != null &amp; !(localValue instanceof SetFuture)) {</a>
+<span class="sourceLineNo">511</span><a id="line.511">      return getDoneValue(localValue);</a>
+<span class="sourceLineNo">512</span><a id="line.512">    }</a>
+<span class="sourceLineNo">513</span><a id="line.513">    // we delay calling nanoTime until we know we will need to either park or spin</a>
+<span class="sourceLineNo">514</span><a id="line.514">    final long endNanos = remainingNanos &gt; 0 ? System.nanoTime() + remainingNanos : 0;</a>
+<span class="sourceLineNo">515</span><a id="line.515">    long_wait_loop:</a>
+<span class="sourceLineNo">516</span><a id="line.516">    if (remainingNanos &gt;= SPIN_THRESHOLD_NANOS) {</a>
+<span class="sourceLineNo">517</span><a id="line.517">      Waiter oldHead = waiters;</a>
+<span class="sourceLineNo">518</span><a id="line.518">      if (oldHead != Waiter.TOMBSTONE) {</a>
+<span class="sourceLineNo">519</span><a id="line.519">        Waiter node = new Waiter();</a>
+<span class="sourceLineNo">520</span><a id="line.520">        do {</a>
+<span class="sourceLineNo">521</span><a id="line.521">          node.setNext(oldHead);</a>
+<span class="sourceLineNo">522</span><a id="line.522">          if (ATOMIC_HELPER.casWaiters(this, oldHead, node)) {</a>
+<span class="sourceLineNo">523</span><a id="line.523">            while (true) {</a>
+<span class="sourceLineNo">524</span><a id="line.524">              OverflowAvoidingLockSupport.parkNanos(this, remainingNanos);</a>
+<span class="sourceLineNo">525</span><a id="line.525">              // Check interruption first, if we woke up due to interruption we need to honor that.</a>
+<span class="sourceLineNo">526</span><a id="line.526">              if (Thread.interrupted()) {</a>
+<span class="sourceLineNo">527</span><a id="line.527">                removeWaiter(node);</a>
+<span class="sourceLineNo">528</span><a id="line.528">                throw new InterruptedException();</a>
+<span class="sourceLineNo">529</span><a id="line.529">              }</a>
+<span class="sourceLineNo">530</span><a id="line.530"></a>
+<span class="sourceLineNo">531</span><a id="line.531">              // Otherwise re-read and check doneness. If we loop then it must have been a spurious</a>
+<span class="sourceLineNo">532</span><a id="line.532">              // wakeup</a>
+<span class="sourceLineNo">533</span><a id="line.533">              localValue = value;</a>
+<span class="sourceLineNo">534</span><a id="line.534">              if (localValue != null &amp; !(localValue instanceof SetFuture)) {</a>
+<span class="sourceLineNo">535</span><a id="line.535">                return getDoneValue(localValue);</a>
+<span class="sourceLineNo">536</span><a id="line.536">              }</a>
+<span class="sourceLineNo">537</span><a id="line.537"></a>
+<span class="sourceLineNo">538</span><a id="line.538">              // timed out?</a>
+<span class="sourceLineNo">539</span><a id="line.539">              remainingNanos = endNanos - System.nanoTime();</a>
+<span class="sourceLineNo">540</span><a id="line.540">              if (remainingNanos &lt; SPIN_THRESHOLD_NANOS) {</a>
+<span class="sourceLineNo">541</span><a id="line.541">                // Remove the waiter, one way or another we are done parking this thread.</a>
+<span class="sourceLineNo">542</span><a id="line.542">                removeWaiter(node);</a>
+<span class="sourceLineNo">543</span><a id="line.543">                break long_wait_loop; // jump down to the busy wait loop</a>
+<span class="sourceLineNo">544</span><a id="line.544">              }</a>
+<span class="sourceLineNo">545</span><a id="line.545">            }</a>
+<span class="sourceLineNo">546</span><a id="line.546">          }</a>
+<span class="sourceLineNo">547</span><a id="line.547">          oldHead = waiters; // re-read and loop.</a>
+<span class="sourceLineNo">548</span><a id="line.548">        } while (oldHead != Waiter.TOMBSTONE);</a>
+<span class="sourceLineNo">549</span><a id="line.549">      }</a>
+<span class="sourceLineNo">550</span><a id="line.550">      // re-read value, if we get here then we must have observed a TOMBSTONE while trying to add a</a>
+<span class="sourceLineNo">551</span><a id="line.551">      // waiter.</a>
+<span class="sourceLineNo">552</span><a id="line.552">      // requireNonNull is safe because value is always set before TOMBSTONE.</a>
+<span class="sourceLineNo">553</span><a id="line.553">      return getDoneValue(requireNonNull(value));</a>
 <span class="sourceLineNo">554</span><a id="line.554">    }</a>
-<span class="sourceLineNo">555</span><a id="line.555">    @RetainedLocalRef Object localValue = value;</a>
-<span class="sourceLineNo">556</span><a id="line.556">    if (localValue != null &amp; !(localValue instanceof SetFuture)) {</a>
-<span class="sourceLineNo">557</span><a id="line.557">      return getDoneValue(localValue);</a>
-<span class="sourceLineNo">558</span><a id="line.558">    }</a>
-<span class="sourceLineNo">559</span><a id="line.559">    Waiter oldHead = waiters;</a>
-<span class="sourceLineNo">560</span><a id="line.560">    if (oldHead != Waiter.TOMBSTONE) {</a>
-<span class="sourceLineNo">561</span><a id="line.561">      Waiter node = new Waiter();</a>
-<span class="sourceLineNo">562</span><a id="line.562">      do {</a>
-<span class="sourceLineNo">563</span><a id="line.563">        node.setNext(oldHead);</a>
-<span class="sourceLineNo">564</span><a id="line.564">        if (ATOMIC_HELPER.casWaiters(this, oldHead, node)) {</a>
-<span class="sourceLineNo">565</span><a id="line.565">          // we are on the stack, now wait for completion.</a>
-<span class="sourceLineNo">566</span><a id="line.566">          while (true) {</a>
-<span class="sourceLineNo">567</span><a id="line.567">            LockSupport.park(this);</a>
-<span class="sourceLineNo">568</span><a id="line.568">            // Check interruption first, if we woke up due to interruption we need to honor that.</a>
-<span class="sourceLineNo">569</span><a id="line.569">            if (Thread.interrupted()) {</a>
-<span class="sourceLineNo">570</span><a id="line.570">              removeWaiter(node);</a>
-<span class="sourceLineNo">571</span><a id="line.571">              throw new InterruptedException();</a>
-<span class="sourceLineNo">572</span><a id="line.572">            }</a>
-<span class="sourceLineNo">573</span><a id="line.573">            // Otherwise re-read and check doneness. If we loop then it must have been a spurious</a>
-<span class="sourceLineNo">574</span><a id="line.574">            // wakeup</a>
-<span class="sourceLineNo">575</span><a id="line.575">            localValue = value;</a>
-<span class="sourceLineNo">576</span><a id="line.576">            if (localValue != null &amp; !(localValue instanceof SetFuture)) {</a>
-<span class="sourceLineNo">577</span><a id="line.577">              return getDoneValue(localValue);</a>
-<span class="sourceLineNo">578</span><a id="line.578">            }</a>
-<span class="sourceLineNo">579</span><a id="line.579">          }</a>
-<span class="sourceLineNo">580</span><a id="line.580">        }</a>
-<span class="sourceLineNo">581</span><a id="line.581">        oldHead = waiters; // re-read and loop.</a>
-<span class="sourceLineNo">582</span><a id="line.582">      } while (oldHead != Waiter.TOMBSTONE);</a>
-<span class="sourceLineNo">583</span><a id="line.583">    }</a>
-<span class="sourceLineNo">584</span><a id="line.584">    // re-read value, if we get here then we must have observed a TOMBSTONE while trying to add a</a>
-<span class="sourceLineNo">585</span><a id="line.585">    // waiter.</a>
-<span class="sourceLineNo">586</span><a id="line.586">    // requireNonNull is safe because value is always set before TOMBSTONE.</a>
-<span class="sourceLineNo">587</span><a id="line.587">    return getDoneValue(requireNonNull(value));</a>
-<span class="sourceLineNo">588</span><a id="line.588">  }</a>
-<span class="sourceLineNo">589</span><a id="line.589"></a>
-<span class="sourceLineNo">590</span><a id="line.590">  /** Unboxes {@code obj}. Assumes that obj is not {@code null} or a {@link SetFuture}. */</a>
-<span class="sourceLineNo">591</span><a id="line.591">  @ParametricNullness</a>
-<span class="sourceLineNo">592</span><a id="line.592">  private V getDoneValue(Object obj) throws ExecutionException {</a>
-<span class="sourceLineNo">593</span><a id="line.593">    // While this seems like it might be too branch-y, simple benchmarking proves it to be</a>
-<span class="sourceLineNo">594</span><a id="line.594">    // unmeasurable (comparing done AbstractFutures with immediateFuture)</a>
-<span class="sourceLineNo">595</span><a id="line.595">    if (obj instanceof Cancellation) {</a>
-<span class="sourceLineNo">596</span><a id="line.596">      Cancellation cancellation = (Cancellation) obj;</a>
-<span class="sourceLineNo">597</span><a id="line.597">      Throwable cause = cancellation.cause;</a>
-<span class="sourceLineNo">598</span><a id="line.598">      throw cancellationExceptionWithCause("Task was cancelled.", cause);</a>
-<span class="sourceLineNo">599</span><a id="line.599">    } else if (obj instanceof Failure) {</a>
-<span class="sourceLineNo">600</span><a id="line.600">      Failure failure = (Failure) obj;</a>
-<span class="sourceLineNo">601</span><a id="line.601">      Throwable exception = failure.exception;</a>
-<span class="sourceLineNo">602</span><a id="line.602">      throw new ExecutionException(exception);</a>
-<span class="sourceLineNo">603</span><a id="line.603">    } else if (obj == NULL) {</a>
-<span class="sourceLineNo">604</span><a id="line.604">      /*</a>
-<span class="sourceLineNo">605</span><a id="line.605">       * It's safe to return null because we would only have stored it in the first place if it were</a>
-<span class="sourceLineNo">606</span><a id="line.606">       * a valid value for V.</a>
-<span class="sourceLineNo">607</span><a id="line.607">       */</a>
-<span class="sourceLineNo">608</span><a id="line.608">      return uncheckedNull();</a>
-<span class="sourceLineNo">609</span><a id="line.609">    } else {</a>
-<span class="sourceLineNo">610</span><a id="line.610">      @SuppressWarnings("unchecked") // this is the only other option</a>
-<span class="sourceLineNo">611</span><a id="line.611">      V asV = (V) obj;</a>
-<span class="sourceLineNo">612</span><a id="line.612">      return asV;</a>
-<span class="sourceLineNo">613</span><a id="line.613">    }</a>
-<span class="sourceLineNo">614</span><a id="line.614">  }</a>
-<span class="sourceLineNo">615</span><a id="line.615"></a>
-<span class="sourceLineNo">616</span><a id="line.616">  @Override</a>
-<span class="sourceLineNo">617</span><a id="line.617">  public boolean isDone() {</a>
-<span class="sourceLineNo">618</span><a id="line.618">    @RetainedLocalRef Object localValue = value;</a>
-<span class="sourceLineNo">619</span><a id="line.619">    return localValue != null &amp; !(localValue instanceof SetFuture);</a>
-<span class="sourceLineNo">620</span><a id="line.620">  }</a>
-<span class="sourceLineNo">621</span><a id="line.621"></a>
-<span class="sourceLineNo">622</span><a id="line.622">  @Override</a>
-<span class="sourceLineNo">623</span><a id="line.623">  public boolean isCancelled() {</a>
-<span class="sourceLineNo">624</span><a id="line.624">    @RetainedLocalRef Object localValue = value;</a>
-<span class="sourceLineNo">625</span><a id="line.625">    return localValue instanceof Cancellation;</a>
-<span class="sourceLineNo">626</span><a id="line.626">  }</a>
-<span class="sourceLineNo">627</span><a id="line.627"></a>
-<span class="sourceLineNo">628</span><a id="line.628">  /**</a>
-<span class="sourceLineNo">629</span><a id="line.629">   * {@inheritDoc}</a>
-<span class="sourceLineNo">630</span><a id="line.630">   *</a>
-<span class="sourceLineNo">631</span><a id="line.631">   * &lt;p&gt;If a cancellation attempt succeeds on a {@code Future} that had previously been {@linkplain</a>
-<span class="sourceLineNo">632</span><a id="line.632">   * #setFuture set asynchronously}, then the cancellation will also be propagated to the delegate</a>
-<span class="sourceLineNo">633</span><a id="line.633">   * {@code Future} that was supplied in the {@code setFuture} call.</a>
-<span class="sourceLineNo">634</span><a id="line.634">   *</a>
-<span class="sourceLineNo">635</span><a id="line.635">   * &lt;p&gt;Rather than override this method to perform additional cancellation work or cleanup,</a>
-<span class="sourceLineNo">636</span><a id="line.636">   * subclasses should override {@link #afterDone}, consulting {@link #isCancelled} and {@link</a>
-<span class="sourceLineNo">637</span><a id="line.637">   * #wasInterrupted} as necessary. This ensures that the work is done even if the future is</a>
-<span class="sourceLineNo">638</span><a id="line.638">   * cancelled without a call to {@code cancel}, such as by calling {@code</a>
-<span class="sourceLineNo">639</span><a id="line.639">   * setFuture(cancelledFuture)}.</a>
-<span class="sourceLineNo">640</span><a id="line.640">   *</a>
-<span class="sourceLineNo">641</span><a id="line.641">   * &lt;p&gt;Beware of completing a future while holding a lock. Its listeners may do slow work or</a>
-<span class="sourceLineNo">642</span><a id="line.642">   * acquire other locks, risking deadlocks.</a>
-<span class="sourceLineNo">643</span><a id="line.643">   */</a>
-<span class="sourceLineNo">644</span><a id="line.644">  @CanIgnoreReturnValue</a>
-<span class="sourceLineNo">645</span><a id="line.645">  @Override</a>
-<span class="sourceLineNo">646</span><a id="line.646">  public boolean cancel(boolean mayInterruptIfRunning) {</a>
-<span class="sourceLineNo">647</span><a id="line.647">    @RetainedLocalRef Object localValue = value;</a>
-<span class="sourceLineNo">648</span><a id="line.648">    boolean rValue = false;</a>
-<span class="sourceLineNo">649</span><a id="line.649">    if (localValue == null | localValue instanceof SetFuture) {</a>
-<span class="sourceLineNo">650</span><a id="line.650">      // Try to delay allocating the exception. At this point we may still lose the CAS, but it is</a>
-<span class="sourceLineNo">651</span><a id="line.651">      // certainly less likely.</a>
-<span class="sourceLineNo">652</span><a id="line.652">      Object valueToSet =</a>
-<span class="sourceLineNo">653</span><a id="line.653">          GENERATE_CANCELLATION_CAUSES</a>
-<span class="sourceLineNo">654</span><a id="line.654">              ? new Cancellation(</a>
-<span class="sourceLineNo">655</span><a id="line.655">                  mayInterruptIfRunning, new CancellationException("Future.cancel() was called."))</a>
-<span class="sourceLineNo">656</span><a id="line.656">              /*</a>
-<span class="sourceLineNo">657</span><a id="line.657">               * requireNonNull is safe because we've initialized these if</a>
-<span class="sourceLineNo">658</span><a id="line.658">               * !GENERATE_CANCELLATION_CAUSES.</a>
-<span class="sourceLineNo">659</span><a id="line.659">               *</a>
-<span class="sourceLineNo">660</span><a id="line.660">               * TODO(cpovirk): Maybe it would be cleaner to define a CancellationSupplier interface</a>
-<span class="sourceLineNo">661</span><a id="line.661">               * with two implementations, one that contains causeless Cancellation instances and</a>
-<span class="sourceLineNo">662</span><a id="line.662">               * the other of which creates new Cancellation instances each time it's called? Yet</a>
-<span class="sourceLineNo">663</span><a id="line.663">               * another alternative is to fill in a non-null value for each of the fields no matter</a>
-<span class="sourceLineNo">664</span><a id="line.664">               * what and to just not use it if !GENERATE_CANCELLATION_CAUSES.</a>
-<span class="sourceLineNo">665</span><a id="line.665">               */</a>
-<span class="sourceLineNo">666</span><a id="line.666">              : requireNonNull(</a>
-<span class="sourceLineNo">667</span><a id="line.667">                  mayInterruptIfRunning</a>
-<span class="sourceLineNo">668</span><a id="line.668">                      ? Cancellation.CAUSELESS_INTERRUPTED</a>
-<span class="sourceLineNo">669</span><a id="line.669">                      : Cancellation.CAUSELESS_CANCELLED);</a>
-<span class="sourceLineNo">670</span><a id="line.670">      AbstractFuture&lt;?&gt; abstractFuture = this;</a>
-<span class="sourceLineNo">671</span><a id="line.671">      while (true) {</a>
-<span class="sourceLineNo">672</span><a id="line.672">        if (ATOMIC_HELPER.casValue(abstractFuture, localValue, valueToSet)) {</a>
-<span class="sourceLineNo">673</span><a id="line.673">          rValue = true;</a>
-<span class="sourceLineNo">674</span><a id="line.674">          complete(abstractFuture, mayInterruptIfRunning);</a>
-<span class="sourceLineNo">675</span><a id="line.675">          if (localValue instanceof SetFuture) {</a>
-<span class="sourceLineNo">676</span><a id="line.676">            // propagate cancellation to the future set in setfuture, this is racy, and we don't</a>
-<span class="sourceLineNo">677</span><a id="line.677">            // care if we are successful or not.</a>
-<span class="sourceLineNo">678</span><a id="line.678">            ListenableFuture&lt;?&gt; futureToPropagateTo = ((SetFuture) localValue).future;</a>
-<span class="sourceLineNo">679</span><a id="line.679">            if (futureToPropagateTo instanceof Trusted) {</a>
-<span class="sourceLineNo">680</span><a id="line.680">              // If the future is a TrustedFuture then we specifically avoid calling cancel()</a>
-<span class="sourceLineNo">681</span><a id="line.681">              // this has 2 benefits</a>
-<span class="sourceLineNo">682</span><a id="line.682">              // 1. for long chains of futures strung together with setFuture we consume less stack</a>
-<span class="sourceLineNo">683</span><a id="line.683">              // 2. we avoid allocating Cancellation objects at every level of the cancellation</a>
-<span class="sourceLineNo">684</span><a id="line.684">              //    chain</a>
-<span class="sourceLineNo">685</span><a id="line.685">              // We can only do this for TrustedFuture, because TrustedFuture.cancel is final and</a>
-<span class="sourceLineNo">686</span><a id="line.686">              // does nothing but delegate to this method.</a>
-<span class="sourceLineNo">687</span><a id="line.687">              AbstractFuture&lt;?&gt; trusted = (AbstractFuture&lt;?&gt;) futureToPropagateTo;</a>
-<span class="sourceLineNo">688</span><a id="line.688">              localValue = trusted.value;</a>
-<span class="sourceLineNo">689</span><a id="line.689">              if (localValue == null | localValue instanceof SetFuture) {</a>
-<span class="sourceLineNo">690</span><a id="line.690">                abstractFuture = trusted;</a>
-<span class="sourceLineNo">691</span><a id="line.691">                continue; // loop back up and try to complete the new future</a>
-<span class="sourceLineNo">692</span><a id="line.692">              }</a>
-<span class="sourceLineNo">693</span><a id="line.693">            } else {</a>
-<span class="sourceLineNo">694</span><a id="line.694">              // not a TrustedFuture, call cancel directly.</a>
-<span class="sourceLineNo">695</span><a id="line.695">              futureToPropagateTo.cancel(mayInterruptIfRunning);</a>
-<span class="sourceLineNo">696</span><a id="line.696">            }</a>
-<span class="sourceLineNo">697</span><a id="line.697">          }</a>
-<span class="sourceLineNo">698</span><a id="line.698">          break;</a>
-<span class="sourceLineNo">699</span><a id="line.699">        }</a>
-<span class="sourceLineNo">700</span><a id="line.700">        // obj changed, reread</a>
-<span class="sourceLineNo">701</span><a id="line.701">        localValue = abstractFuture.value;</a>
-<span class="sourceLineNo">702</span><a id="line.702">        if (!(localValue instanceof SetFuture)) {</a>
-<span class="sourceLineNo">703</span><a id="line.703">          // obj cannot be null at this point, because value can only change from null to non-null.</a>
-<span class="sourceLineNo">704</span><a id="line.704">          // So if value changed (and it did since we lost the CAS), then it cannot be null and</a>
-<span class="sourceLineNo">705</span><a id="line.705">          // since it isn't a SetFuture, then the future must be done and we should exit the loop</a>
-<span class="sourceLineNo">706</span><a id="line.706">          break;</a>
-<span class="sourceLineNo">707</span><a id="line.707">        }</a>
-<span class="sourceLineNo">708</span><a id="line.708">      }</a>
-<span class="sourceLineNo">709</span><a id="line.709">    }</a>
-<span class="sourceLineNo">710</span><a id="line.710">    return rValue;</a>
-<span class="sourceLineNo">711</span><a id="line.711">  }</a>
-<span class="sourceLineNo">712</span><a id="line.712"></a>
-<span class="sourceLineNo">713</span><a id="line.713">  /**</a>
-<span class="sourceLineNo">714</span><a id="line.714">   * Subclasses can override this method to implement interruption of the future's computation. The</a>
-<span class="sourceLineNo">715</span><a id="line.715">   * method is invoked automatically by a successful call to {@link #cancel(boolean) cancel(true)}.</a>
-<span class="sourceLineNo">716</span><a id="line.716">   *</a>
-<span class="sourceLineNo">717</span><a id="line.717">   * &lt;p&gt;The default implementation does nothing.</a>
-<span class="sourceLineNo">718</span><a id="line.718">   *</a>
-<span class="sourceLineNo">719</span><a id="line.719">   * &lt;p&gt;This method is likely to be deprecated. Prefer to override {@link #afterDone}, checking</a>
-<span class="sourceLineNo">720</span><a id="line.720">   * {@link #wasInterrupted} to decide whether to interrupt your task.</a>
-<span class="sourceLineNo">721</span><a id="line.721">   *</a>
-<span class="sourceLineNo">722</span><a id="line.722">   * @since 10.0</a>
-<span class="sourceLineNo">723</span><a id="line.723">   */</a>
-<span class="sourceLineNo">724</span><a id="line.724">  protected void interruptTask() {}</a>
-<span class="sourceLineNo">725</span><a id="line.725"></a>
-<span class="sourceLineNo">726</span><a id="line.726">  /**</a>
-<span class="sourceLineNo">727</span><a id="line.727">   * Returns true if this future was cancelled with {@code mayInterruptIfRunning} set to {@code</a>
-<span class="sourceLineNo">728</span><a id="line.728">   * true}.</a>
-<span class="sourceLineNo">729</span><a id="line.729">   *</a>
-<span class="sourceLineNo">730</span><a id="line.730">   * @since 14.0</a>
-<span class="sourceLineNo">731</span><a id="line.731">   */</a>
-<span class="sourceLineNo">732</span><a id="line.732">  protected final boolean wasInterrupted() {</a>
-<span class="sourceLineNo">733</span><a id="line.733">    @RetainedLocalRef Object localValue = value;</a>
-<span class="sourceLineNo">734</span><a id="line.734">    return (localValue instanceof Cancellation) &amp;&amp; ((Cancellation) localValue).wasInterrupted;</a>
-<span class="sourceLineNo">735</span><a id="line.735">  }</a>
-<span class="sourceLineNo">736</span><a id="line.736"></a>
-<span class="sourceLineNo">737</span><a id="line.737">  /**</a>
-<span class="sourceLineNo">738</span><a id="line.738">   * {@inheritDoc}</a>
-<span class="sourceLineNo">739</span><a id="line.739">   *</a>
-<span class="sourceLineNo">740</span><a id="line.740">   * @since 10.0</a>
-<span class="sourceLineNo">741</span><a id="line.741">   */</a>
-<span class="sourceLineNo">742</span><a id="line.742">  @Override</a>
-<span class="sourceLineNo">743</span><a id="line.743">  public void addListener(Runnable listener, Executor executor) {</a>
-<span class="sourceLineNo">744</span><a id="line.744">    checkNotNull(listener, "Runnable was null.");</a>
-<span class="sourceLineNo">745</span><a id="line.745">    checkNotNull(executor, "Executor was null.");</a>
-<span class="sourceLineNo">746</span><a id="line.746">    // Checking isDone and listeners != TOMBSTONE may seem redundant, but our contract for</a>
-<span class="sourceLineNo">747</span><a id="line.747">    // addListener says that listeners execute 'immediate' if the future isDone(). However, our</a>
-<span class="sourceLineNo">748</span><a id="line.748">    // protocol for completing a future is to assign the value field (which sets isDone to true) and</a>
-<span class="sourceLineNo">749</span><a id="line.749">    // then to release waiters, followed by executing afterDone(), followed by releasing listeners.</a>
-<span class="sourceLineNo">750</span><a id="line.750">    // That means that it is possible to observe that the future isDone and that your listeners</a>
-<span class="sourceLineNo">751</span><a id="line.751">    // don't execute 'immediately'.  By checking isDone here we avoid that.</a>
-<span class="sourceLineNo">752</span><a id="line.752">    // A corollary to all that is that we don't need to check isDone inside the loop because if we</a>
-<span class="sourceLineNo">753</span><a id="line.753">    // get into the loop we know that we weren't done when we entered and therefore we aren't under</a>
-<span class="sourceLineNo">754</span><a id="line.754">    // an obligation to execute 'immediately'.</a>
-<span class="sourceLineNo">755</span><a id="line.755">    if (!isDone()) {</a>
-<span class="sourceLineNo">756</span><a id="line.756">      Listener oldHead = listeners;</a>
-<span class="sourceLineNo">757</span><a id="line.757">      if (oldHead != Listener.TOMBSTONE) {</a>
-<span class="sourceLineNo">758</span><a id="line.758">        Listener newNode = new Listener(listener, executor);</a>
-<span class="sourceLineNo">759</span><a id="line.759">        do {</a>
-<span class="sourceLineNo">760</span><a id="line.760">          newNode.next = oldHead;</a>
-<span class="sourceLineNo">761</span><a id="line.761">          if (ATOMIC_HELPER.casListeners(this, oldHead, newNode)) {</a>
-<span class="sourceLineNo">762</span><a id="line.762">            return;</a>
-<span class="sourceLineNo">763</span><a id="line.763">          }</a>
-<span class="sourceLineNo">764</span><a id="line.764">          oldHead = listeners; // re-read</a>
-<span class="sourceLineNo">765</span><a id="line.765">        } while (oldHead != Listener.TOMBSTONE);</a>
-<span class="sourceLineNo">766</span><a id="line.766">      }</a>
-<span class="sourceLineNo">767</span><a id="line.767">    }</a>
-<span class="sourceLineNo">768</span><a id="line.768">    // If we get here then the Listener TOMBSTONE was set, which means the future is done, call</a>
-<span class="sourceLineNo">769</span><a id="line.769">    // the listener.</a>
-<span class="sourceLineNo">770</span><a id="line.770">    executeListener(listener, executor);</a>
-<span class="sourceLineNo">771</span><a id="line.771">  }</a>
-<span class="sourceLineNo">772</span><a id="line.772"></a>
-<span class="sourceLineNo">773</span><a id="line.773">  /**</a>
-<span class="sourceLineNo">774</span><a id="line.774">   * Sets the result of this {@code Future} unless this {@code Future} has already been cancelled or</a>
-<span class="sourceLineNo">775</span><a id="line.775">   * set (including {@linkplain #setFuture set asynchronously}). When a call to this method returns,</a>
-<span class="sourceLineNo">776</span><a id="line.776">   * the {@code Future} is guaranteed to be {@linkplain #isDone done} &lt;b&gt;only if&lt;/b&gt; the call was</a>
-<span class="sourceLineNo">777</span><a id="line.777">   * accepted (in which case it returns {@code true}). If it returns {@code false}, the {@code</a>
-<span class="sourceLineNo">778</span><a id="line.778">   * Future} may have previously been set asynchronously, in which case its result may not be known</a>
-<span class="sourceLineNo">779</span><a id="line.779">   * yet. That result, though not yet known, cannot be overridden by a call to a {@code set*}</a>
-<span class="sourceLineNo">780</span><a id="line.780">   * method, only by a call to {@link #cancel}.</a>
-<span class="sourceLineNo">781</span><a id="line.781">   *</a>
-<span class="sourceLineNo">782</span><a id="line.782">   * &lt;p&gt;Beware of completing a future while holding a lock. Its listeners may do slow work or</a>
-<span class="sourceLineNo">783</span><a id="line.783">   * acquire other locks, risking deadlocks.</a>
-<span class="sourceLineNo">784</span><a id="line.784">   *</a>
-<span class="sourceLineNo">785</span><a id="line.785">   * @param value the value to be used as the result</a>
-<span class="sourceLineNo">786</span><a id="line.786">   * @return true if the attempt was accepted, completing the {@code Future}</a>
-<span class="sourceLineNo">787</span><a id="line.787">   */</a>
-<span class="sourceLineNo">788</span><a id="line.788">  @CanIgnoreReturnValue</a>
-<span class="sourceLineNo">789</span><a id="line.789">  protected boolean set(@ParametricNullness V value) {</a>
-<span class="sourceLineNo">790</span><a id="line.790">    Object valueToSet = value == null ? NULL : value;</a>
-<span class="sourceLineNo">791</span><a id="line.791">    if (ATOMIC_HELPER.casValue(this, null, valueToSet)) {</a>
-<span class="sourceLineNo">792</span><a id="line.792">      complete(this, /*callInterruptTask=*/ false);</a>
-<span class="sourceLineNo">793</span><a id="line.793">      return true;</a>
-<span class="sourceLineNo">794</span><a id="line.794">    }</a>
-<span class="sourceLineNo">795</span><a id="line.795">    return false;</a>
-<span class="sourceLineNo">796</span><a id="line.796">  }</a>
-<span class="sourceLineNo">797</span><a id="line.797"></a>
-<span class="sourceLineNo">798</span><a id="line.798">  /**</a>
-<span class="sourceLineNo">799</span><a id="line.799">   * Sets the failed result of this {@code Future} unless this {@code Future} has already been</a>
-<span class="sourceLineNo">800</span><a id="line.800">   * cancelled or set (including {@linkplain #setFuture set asynchronously}). When a call to this</a>
-<span class="sourceLineNo">801</span><a id="line.801">   * method returns, the {@code Future} is guaranteed to be {@linkplain #isDone done} &lt;b&gt;only if&lt;/b&gt;</a>
-<span class="sourceLineNo">802</span><a id="line.802">   * the call was accepted (in which case it returns {@code true}). If it returns {@code false}, the</a>
-<span class="sourceLineNo">803</span><a id="line.803">   * {@code Future} may have previously been set asynchronously, in which case its result may not be</a>
-<span class="sourceLineNo">804</span><a id="line.804">   * known yet. That result, though not yet known, cannot be overridden by a call to a {@code set*}</a>
-<span class="sourceLineNo">805</span><a id="line.805">   * method, only by a call to {@link #cancel}.</a>
-<span class="sourceLineNo">806</span><a id="line.806">   *</a>
-<span class="sourceLineNo">807</span><a id="line.807">   * &lt;p&gt;Beware of completing a future while holding a lock. Its listeners may do slow work or</a>
-<span class="sourceLineNo">808</span><a id="line.808">   * acquire other locks, risking deadlocks.</a>
-<span class="sourceLineNo">809</span><a id="line.809">   *</a>
-<span class="sourceLineNo">810</span><a id="line.810">   * @param throwable the exception to be used as the failed result</a>
-<span class="sourceLineNo">811</span><a id="line.811">   * @return true if the attempt was accepted, completing the {@code Future}</a>
-<span class="sourceLineNo">812</span><a id="line.812">   */</a>
-<span class="sourceLineNo">813</span><a id="line.813">  @CanIgnoreReturnValue</a>
-<span class="sourceLineNo">814</span><a id="line.814">  protected boolean setException(Throwable throwable) {</a>
-<span class="sourceLineNo">815</span><a id="line.815">    Object valueToSet = new Failure(checkNotNull(throwable));</a>
-<span class="sourceLineNo">816</span><a id="line.816">    if (ATOMIC_HELPER.casValue(this, null, valueToSet)) {</a>
-<span class="sourceLineNo">817</span><a id="line.817">      complete(this, /*callInterruptTask=*/ false);</a>
-<span class="sourceLineNo">818</span><a id="line.818">      return true;</a>
-<span class="sourceLineNo">819</span><a id="line.819">    }</a>
-<span class="sourceLineNo">820</span><a id="line.820">    return false;</a>
-<span class="sourceLineNo">821</span><a id="line.821">  }</a>
-<span class="sourceLineNo">822</span><a id="line.822"></a>
-<span class="sourceLineNo">823</span><a id="line.823">  /**</a>
-<span class="sourceLineNo">824</span><a id="line.824">   * Sets the result of this {@code Future} to match the supplied input {@code Future} once the</a>
-<span class="sourceLineNo">825</span><a id="line.825">   * supplied {@code Future} is done, unless this {@code Future} has already been cancelled or set</a>
-<span class="sourceLineNo">826</span><a id="line.826">   * (including "set asynchronously," defined below).</a>
-<span class="sourceLineNo">827</span><a id="line.827">   *</a>
-<span class="sourceLineNo">828</span><a id="line.828">   * &lt;p&gt;If the supplied future is {@linkplain #isDone done} when this method is called and the call</a>
-<span class="sourceLineNo">829</span><a id="line.829">   * is accepted, then this future is guaranteed to have been completed with the supplied future by</a>
-<span class="sourceLineNo">830</span><a id="line.830">   * the time this method returns. If the supplied future is not done and the call is accepted, then</a>
-<span class="sourceLineNo">831</span><a id="line.831">   * the future will be &lt;i&gt;set asynchronously&lt;/i&gt;. Note that such a result, though not yet known,</a>
-<span class="sourceLineNo">832</span><a id="line.832">   * cannot be overridden by a call to a {@code set*} method, only by a call to {@link #cancel}.</a>
-<span class="sourceLineNo">833</span><a id="line.833">   *</a>
-<span class="sourceLineNo">834</span><a id="line.834">   * &lt;p&gt;If the call {@code setFuture(delegate)} is accepted and this {@code Future} is later</a>
-<span class="sourceLineNo">835</span><a id="line.835">   * cancelled, cancellation will be propagated to {@code delegate}. Additionally, any call to</a>
-<span class="sourceLineNo">836</span><a id="line.836">   * {@code setFuture} after any cancellation will propagate cancellation to the supplied {@code</a>
-<span class="sourceLineNo">837</span><a id="line.837">   * Future}.</a>
-<span class="sourceLineNo">838</span><a id="line.838">   *</a>
-<span class="sourceLineNo">839</span><a id="line.839">   * &lt;p&gt;Note that, even if the supplied future is cancelled and it causes this future to complete,</a>
-<span class="sourceLineNo">840</span><a id="line.840">   * it will never trigger interruption behavior. In particular, it will not cause this future to</a>
-<span class="sourceLineNo">841</span><a id="line.841">   * invoke the {@link #interruptTask} method, and the {@link #wasInterrupted} method will not</a>
-<span class="sourceLineNo">842</span><a id="line.842">   * return {@code true}.</a>
+<span class="sourceLineNo">555</span><a id="line.555">    // If we get here then we have remainingNanos &lt; SPIN_THRESHOLD_NANOS and there is no node on the</a>
+<span class="sourceLineNo">556</span><a id="line.556">    // waiters list</a>
+<span class="sourceLineNo">557</span><a id="line.557">    while (remainingNanos &gt; 0) {</a>
+<span class="sourceLineNo">558</span><a id="line.558">      localValue = value;</a>
+<span class="sourceLineNo">559</span><a id="line.559">      if (localValue != null &amp; !(localValue instanceof SetFuture)) {</a>
+<span class="sourceLineNo">560</span><a id="line.560">        return getDoneValue(localValue);</a>
+<span class="sourceLineNo">561</span><a id="line.561">      }</a>
+<span class="sourceLineNo">562</span><a id="line.562">      if (Thread.interrupted()) {</a>
+<span class="sourceLineNo">563</span><a id="line.563">        throw new InterruptedException();</a>
+<span class="sourceLineNo">564</span><a id="line.564">      }</a>
+<span class="sourceLineNo">565</span><a id="line.565">      remainingNanos = endNanos - System.nanoTime();</a>
+<span class="sourceLineNo">566</span><a id="line.566">    }</a>
+<span class="sourceLineNo">567</span><a id="line.567"></a>
+<span class="sourceLineNo">568</span><a id="line.568">    String futureToString = toString();</a>
+<span class="sourceLineNo">569</span><a id="line.569">    final String unitString = unit.toString().toLowerCase(Locale.ROOT);</a>
+<span class="sourceLineNo">570</span><a id="line.570">    String message = "Waited " + timeout + " " + unit.toString().toLowerCase(Locale.ROOT);</a>
+<span class="sourceLineNo">571</span><a id="line.571">    // Only report scheduling delay if larger than our spin threshold - otherwise it's just noise</a>
+<span class="sourceLineNo">572</span><a id="line.572">    if (remainingNanos + SPIN_THRESHOLD_NANOS &lt; 0) {</a>
+<span class="sourceLineNo">573</span><a id="line.573">      // We over-waited for our timeout.</a>
+<span class="sourceLineNo">574</span><a id="line.574">      message += " (plus ";</a>
+<span class="sourceLineNo">575</span><a id="line.575">      long overWaitNanos = -remainingNanos;</a>
+<span class="sourceLineNo">576</span><a id="line.576">      long overWaitUnits = unit.convert(overWaitNanos, NANOSECONDS);</a>
+<span class="sourceLineNo">577</span><a id="line.577">      long overWaitLeftoverNanos = overWaitNanos - unit.toNanos(overWaitUnits);</a>
+<span class="sourceLineNo">578</span><a id="line.578">      boolean shouldShowExtraNanos =</a>
+<span class="sourceLineNo">579</span><a id="line.579">          overWaitUnits == 0 || overWaitLeftoverNanos &gt; SPIN_THRESHOLD_NANOS;</a>
+<span class="sourceLineNo">580</span><a id="line.580">      if (overWaitUnits &gt; 0) {</a>
+<span class="sourceLineNo">581</span><a id="line.581">        message += overWaitUnits + " " + unitString;</a>
+<span class="sourceLineNo">582</span><a id="line.582">        if (shouldShowExtraNanos) {</a>
+<span class="sourceLineNo">583</span><a id="line.583">          message += ",";</a>
+<span class="sourceLineNo">584</span><a id="line.584">        }</a>
+<span class="sourceLineNo">585</span><a id="line.585">        message += " ";</a>
+<span class="sourceLineNo">586</span><a id="line.586">      }</a>
+<span class="sourceLineNo">587</span><a id="line.587">      if (shouldShowExtraNanos) {</a>
+<span class="sourceLineNo">588</span><a id="line.588">        message += overWaitLeftoverNanos + " nanoseconds ";</a>
+<span class="sourceLineNo">589</span><a id="line.589">      }</a>
+<span class="sourceLineNo">590</span><a id="line.590"></a>
+<span class="sourceLineNo">591</span><a id="line.591">      message += "delay)";</a>
+<span class="sourceLineNo">592</span><a id="line.592">    }</a>
+<span class="sourceLineNo">593</span><a id="line.593">    // It's confusing to see a completed future in a timeout message; if isDone() returns false,</a>
+<span class="sourceLineNo">594</span><a id="line.594">    // then we know it must have given a pending toString value earlier. If not, then the future</a>
+<span class="sourceLineNo">595</span><a id="line.595">    // completed after the timeout expired, and the message might be success.</a>
+<span class="sourceLineNo">596</span><a id="line.596">    if (isDone()) {</a>
+<span class="sourceLineNo">597</span><a id="line.597">      throw new TimeoutException(message + " but future completed as timeout expired");</a>
+<span class="sourceLineNo">598</span><a id="line.598">    }</a>
+<span class="sourceLineNo">599</span><a id="line.599">    throw new TimeoutException(message + " for " + futureToString);</a>
+<span class="sourceLineNo">600</span><a id="line.600">  }</a>
+<span class="sourceLineNo">601</span><a id="line.601"></a>
+<span class="sourceLineNo">602</span><a id="line.602">  /**</a>
+<span class="sourceLineNo">603</span><a id="line.603">   * {@inheritDoc}</a>
+<span class="sourceLineNo">604</span><a id="line.604">   *</a>
+<span class="sourceLineNo">605</span><a id="line.605">   * &lt;p&gt;The default {@link AbstractFuture} implementation throws {@code InterruptedException} if the</a>
+<span class="sourceLineNo">606</span><a id="line.606">   * current thread is interrupted during the call, even if the value is already available.</a>
+<span class="sourceLineNo">607</span><a id="line.607">   *</a>
+<span class="sourceLineNo">608</span><a id="line.608">   * @throws CancellationException {@inheritDoc}</a>
+<span class="sourceLineNo">609</span><a id="line.609">   */</a>
+<span class="sourceLineNo">610</span><a id="line.610">  @CanIgnoreReturnValue</a>
+<span class="sourceLineNo">611</span><a id="line.611">  @Override</a>
+<span class="sourceLineNo">612</span><a id="line.612">  @ParametricNullness</a>
+<span class="sourceLineNo">613</span><a id="line.613">  public V get() throws InterruptedException, ExecutionException {</a>
+<span class="sourceLineNo">614</span><a id="line.614">    if (Thread.interrupted()) {</a>
+<span class="sourceLineNo">615</span><a id="line.615">      throw new InterruptedException();</a>
+<span class="sourceLineNo">616</span><a id="line.616">    }</a>
+<span class="sourceLineNo">617</span><a id="line.617">    @RetainedLocalRef Object localValue = value;</a>
+<span class="sourceLineNo">618</span><a id="line.618">    if (localValue != null &amp; !(localValue instanceof SetFuture)) {</a>
+<span class="sourceLineNo">619</span><a id="line.619">      return getDoneValue(localValue);</a>
+<span class="sourceLineNo">620</span><a id="line.620">    }</a>
+<span class="sourceLineNo">621</span><a id="line.621">    Waiter oldHead = waiters;</a>
+<span class="sourceLineNo">622</span><a id="line.622">    if (oldHead != Waiter.TOMBSTONE) {</a>
+<span class="sourceLineNo">623</span><a id="line.623">      Waiter node = new Waiter();</a>
+<span class="sourceLineNo">624</span><a id="line.624">      do {</a>
+<span class="sourceLineNo">625</span><a id="line.625">        node.setNext(oldHead);</a>
+<span class="sourceLineNo">626</span><a id="line.626">        if (ATOMIC_HELPER.casWaiters(this, oldHead, node)) {</a>
+<span class="sourceLineNo">627</span><a id="line.627">          // we are on the stack, now wait for completion.</a>
+<span class="sourceLineNo">628</span><a id="line.628">          while (true) {</a>
+<span class="sourceLineNo">629</span><a id="line.629">            LockSupport.park(this);</a>
+<span class="sourceLineNo">630</span><a id="line.630">            // Check interruption first, if we woke up due to interruption we need to honor that.</a>
+<span class="sourceLineNo">631</span><a id="line.631">            if (Thread.interrupted()) {</a>
+<span class="sourceLineNo">632</span><a id="line.632">              removeWaiter(node);</a>
+<span class="sourceLineNo">633</span><a id="line.633">              throw new InterruptedException();</a>
+<span class="sourceLineNo">634</span><a id="line.634">            }</a>
+<span class="sourceLineNo">635</span><a id="line.635">            // Otherwise re-read and check doneness. If we loop then it must have been a spurious</a>
+<span class="sourceLineNo">636</span><a id="line.636">            // wakeup</a>
+<span class="sourceLineNo">637</span><a id="line.637">            localValue = value;</a>
+<span class="sourceLineNo">638</span><a id="line.638">            if (localValue != null &amp; !(localValue instanceof SetFuture)) {</a>
+<span class="sourceLineNo">639</span><a id="line.639">              return getDoneValue(localValue);</a>
+<span class="sourceLineNo">640</span><a id="line.640">            }</a>
+<span class="sourceLineNo">641</span><a id="line.641">          }</a>
+<span class="sourceLineNo">642</span><a id="line.642">        }</a>
+<span class="sourceLineNo">643</span><a id="line.643">        oldHead = waiters; // re-read and loop.</a>
+<span class="sourceLineNo">644</span><a id="line.644">      } while (oldHead != Waiter.TOMBSTONE);</a>
+<span class="sourceLineNo">645</span><a id="line.645">    }</a>
+<span class="sourceLineNo">646</span><a id="line.646">    // re-read value, if we get here then we must have observed a TOMBSTONE while trying to add a</a>
+<span class="sourceLineNo">647</span><a id="line.647">    // waiter.</a>
+<span class="sourceLineNo">648</span><a id="line.648">    // requireNonNull is safe because value is always set before TOMBSTONE.</a>
+<span class="sourceLineNo">649</span><a id="line.649">    return getDoneValue(requireNonNull(value));</a>
+<span class="sourceLineNo">650</span><a id="line.650">  }</a>
+<span class="sourceLineNo">651</span><a id="line.651"></a>
+<span class="sourceLineNo">652</span><a id="line.652">  /** Unboxes {@code obj}. Assumes that obj is not {@code null} or a {@link SetFuture}. */</a>
+<span class="sourceLineNo">653</span><a id="line.653">  @ParametricNullness</a>
+<span class="sourceLineNo">654</span><a id="line.654">  private V getDoneValue(Object obj) throws ExecutionException {</a>
+<span class="sourceLineNo">655</span><a id="line.655">    // While this seems like it might be too branch-y, simple benchmarking proves it to be</a>
+<span class="sourceLineNo">656</span><a id="line.656">    // unmeasurable (comparing done AbstractFutures with immediateFuture)</a>
+<span class="sourceLineNo">657</span><a id="line.657">    if (obj instanceof Cancellation) {</a>
+<span class="sourceLineNo">658</span><a id="line.658">      Cancellation cancellation = (Cancellation) obj;</a>
+<span class="sourceLineNo">659</span><a id="line.659">      Throwable cause = cancellation.cause;</a>
+<span class="sourceLineNo">660</span><a id="line.660">      throw cancellationExceptionWithCause("Task was cancelled.", cause);</a>
+<span class="sourceLineNo">661</span><a id="line.661">    } else if (obj instanceof Failure) {</a>
+<span class="sourceLineNo">662</span><a id="line.662">      Failure failure = (Failure) obj;</a>
+<span class="sourceLineNo">663</span><a id="line.663">      Throwable exception = failure.exception;</a>
+<span class="sourceLineNo">664</span><a id="line.664">      throw new ExecutionException(exception);</a>
+<span class="sourceLineNo">665</span><a id="line.665">    } else if (obj == NULL) {</a>
+<span class="sourceLineNo">666</span><a id="line.666">      /*</a>
+<span class="sourceLineNo">667</span><a id="line.667">       * It's safe to return null because we would only have stored it in the first place if it were</a>
+<span class="sourceLineNo">668</span><a id="line.668">       * a valid value for V.</a>
+<span class="sourceLineNo">669</span><a id="line.669">       */</a>
+<span class="sourceLineNo">670</span><a id="line.670">      return uncheckedNull();</a>
+<span class="sourceLineNo">671</span><a id="line.671">    } else {</a>
+<span class="sourceLineNo">672</span><a id="line.672">      @SuppressWarnings("unchecked") // this is the only other option</a>
+<span class="sourceLineNo">673</span><a id="line.673">      V asV = (V) obj;</a>
+<span class="sourceLineNo">674</span><a id="line.674">      return asV;</a>
+<span class="sourceLineNo">675</span><a id="line.675">    }</a>
+<span class="sourceLineNo">676</span><a id="line.676">  }</a>
+<span class="sourceLineNo">677</span><a id="line.677"></a>
+<span class="sourceLineNo">678</span><a id="line.678">  @Override</a>
+<span class="sourceLineNo">679</span><a id="line.679">  public boolean isDone() {</a>
+<span class="sourceLineNo">680</span><a id="line.680">    @RetainedLocalRef Object localValue = value;</a>
+<span class="sourceLineNo">681</span><a id="line.681">    return localValue != null &amp; !(localValue instanceof SetFuture);</a>
+<span class="sourceLineNo">682</span><a id="line.682">  }</a>
+<span class="sourceLineNo">683</span><a id="line.683"></a>
+<span class="sourceLineNo">684</span><a id="line.684">  @Override</a>
+<span class="sourceLineNo">685</span><a id="line.685">  public boolean isCancelled() {</a>
+<span class="sourceLineNo">686</span><a id="line.686">    @RetainedLocalRef Object localValue = value;</a>
+<span class="sourceLineNo">687</span><a id="line.687">    return localValue instanceof Cancellation;</a>
+<span class="sourceLineNo">688</span><a id="line.688">  }</a>
+<span class="sourceLineNo">689</span><a id="line.689"></a>
+<span class="sourceLineNo">690</span><a id="line.690">  /**</a>
+<span class="sourceLineNo">691</span><a id="line.691">   * {@inheritDoc}</a>
+<span class="sourceLineNo">692</span><a id="line.692">   *</a>
+<span class="sourceLineNo">693</span><a id="line.693">   * &lt;p&gt;If a cancellation attempt succeeds on a {@code Future} that had previously been {@linkplain</a>
+<span class="sourceLineNo">694</span><a id="line.694">   * #setFuture set asynchronously}, then the cancellation will also be propagated to the delegate</a>
+<span class="sourceLineNo">695</span><a id="line.695">   * {@code Future} that was supplied in the {@code setFuture} call.</a>
+<span class="sourceLineNo">696</span><a id="line.696">   *</a>
+<span class="sourceLineNo">697</span><a id="line.697">   * &lt;p&gt;Rather than override this method to perform additional cancellation work or cleanup,</a>
+<span class="sourceLineNo">698</span><a id="line.698">   * subclasses should override {@link #afterDone}, consulting {@link #isCancelled} and {@link</a>
+<span class="sourceLineNo">699</span><a id="line.699">   * #wasInterrupted} as necessary. This ensures that the work is done even if the future is</a>
+<span class="sourceLineNo">700</span><a id="line.700">   * cancelled without a call to {@code cancel}, such as by calling {@code</a>
+<span class="sourceLineNo">701</span><a id="line.701">   * setFuture(cancelledFuture)}.</a>
+<span class="sourceLineNo">702</span><a id="line.702">   *</a>
+<span class="sourceLineNo">703</span><a id="line.703">   * &lt;p&gt;Beware of completing a future while holding a lock. Its listeners may do slow work or</a>
+<span class="sourceLineNo">704</span><a id="line.704">   * acquire other locks, risking deadlocks.</a>
+<span class="sourceLineNo">705</span><a id="line.705">   */</a>
+<span class="sourceLineNo">706</span><a id="line.706">  @CanIgnoreReturnValue</a>
+<span class="sourceLineNo">707</span><a id="line.707">  @Override</a>
+<span class="sourceLineNo">708</span><a id="line.708">  public boolean cancel(boolean mayInterruptIfRunning) {</a>
+<span class="sourceLineNo">709</span><a id="line.709">    @RetainedLocalRef Object localValue = value;</a>
+<span class="sourceLineNo">710</span><a id="line.710">    boolean rValue = false;</a>
+<span class="sourceLineNo">711</span><a id="line.711">    if (localValue == null | localValue instanceof SetFuture) {</a>
+<span class="sourceLineNo">712</span><a id="line.712">      // Try to delay allocating the exception. At this point we may still lose the CAS, but it is</a>
+<span class="sourceLineNo">713</span><a id="line.713">      // certainly less likely.</a>
+<span class="sourceLineNo">714</span><a id="line.714">      Object valueToSet =</a>
+<span class="sourceLineNo">715</span><a id="line.715">          GENERATE_CANCELLATION_CAUSES</a>
+<span class="sourceLineNo">716</span><a id="line.716">              ? new Cancellation(</a>
+<span class="sourceLineNo">717</span><a id="line.717">                  mayInterruptIfRunning, new CancellationException("Future.cancel() was called."))</a>
+<span class="sourceLineNo">718</span><a id="line.718">              /*</a>
+<span class="sourceLineNo">719</span><a id="line.719">               * requireNonNull is safe because we've initialized these if</a>
+<span class="sourceLineNo">720</span><a id="line.720">               * !GENERATE_CANCELLATION_CAUSES.</a>
+<span class="sourceLineNo">721</span><a id="line.721">               *</a>
+<span class="sourceLineNo">722</span><a id="line.722">               * TODO(cpovirk): Maybe it would be cleaner to define a CancellationSupplier interface</a>
+<span class="sourceLineNo">723</span><a id="line.723">               * with two implementations, one that contains causeless Cancellation instances and</a>
+<span class="sourceLineNo">724</span><a id="line.724">               * the other of which creates new Cancellation instances each time it's called? Yet</a>
+<span class="sourceLineNo">725</span><a id="line.725">               * another alternative is to fill in a non-null value for each of the fields no matter</a>
+<span class="sourceLineNo">726</span><a id="line.726">               * what and to just not use it if !GENERATE_CANCELLATION_CAUSES.</a>
+<span class="sourceLineNo">727</span><a id="line.727">               */</a>
+<span class="sourceLineNo">728</span><a id="line.728">              : requireNonNull(</a>
+<span class="sourceLineNo">729</span><a id="line.729">                  mayInterruptIfRunning</a>
+<span class="sourceLineNo">730</span><a id="line.730">                      ? Cancellation.CAUSELESS_INTERRUPTED</a>
+<span class="sourceLineNo">731</span><a id="line.731">                      : Cancellation.CAUSELESS_CANCELLED);</a>
+<span class="sourceLineNo">732</span><a id="line.732">      AbstractFuture&lt;?&gt; abstractFuture = this;</a>
+<span class="sourceLineNo">733</span><a id="line.733">      while (true) {</a>
+<span class="sourceLineNo">734</span><a id="line.734">        if (ATOMIC_HELPER.casValue(abstractFuture, localValue, valueToSet)) {</a>
+<span class="sourceLineNo">735</span><a id="line.735">          rValue = true;</a>
+<span class="sourceLineNo">736</span><a id="line.736">          complete(abstractFuture, mayInterruptIfRunning);</a>
+<span class="sourceLineNo">737</span><a id="line.737">          if (localValue instanceof SetFuture) {</a>
+<span class="sourceLineNo">738</span><a id="line.738">            // propagate cancellation to the future set in setfuture, this is racy, and we don't</a>
+<span class="sourceLineNo">739</span><a id="line.739">            // care if we are successful or not.</a>
+<span class="sourceLineNo">740</span><a id="line.740">            ListenableFuture&lt;?&gt; futureToPropagateTo = ((SetFuture) localValue).future;</a>
+<span class="sourceLineNo">741</span><a id="line.741">            if (futureToPropagateTo instanceof Trusted) {</a>
+<span class="sourceLineNo">742</span><a id="line.742">              // If the future is a TrustedFuture then we specifically avoid calling cancel()</a>
+<span class="sourceLineNo">743</span><a id="line.743">              // this has 2 benefits</a>
+<span class="sourceLineNo">744</span><a id="line.744">              // 1. for long chains of futures strung together with setFuture we consume less stack</a>
+<span class="sourceLineNo">745</span><a id="line.745">              // 2. we avoid allocating Cancellation objects at every level of the cancellation</a>
+<span class="sourceLineNo">746</span><a id="line.746">              //    chain</a>
+<span class="sourceLineNo">747</span><a id="line.747">              // We can only do this for TrustedFuture, because TrustedFuture.cancel is final and</a>
+<span class="sourceLineNo">748</span><a id="line.748">              // does nothing but delegate to this method.</a>
+<span class="sourceLineNo">749</span><a id="line.749">              AbstractFuture&lt;?&gt; trusted = (AbstractFuture&lt;?&gt;) futureToPropagateTo;</a>
+<span class="sourceLineNo">750</span><a id="line.750">              localValue = trusted.value;</a>
+<span class="sourceLineNo">751</span><a id="line.751">              if (localValue == null | localValue instanceof SetFuture) {</a>
+<span class="sourceLineNo">752</span><a id="line.752">                abstractFuture = trusted;</a>
+<span class="sourceLineNo">753</span><a id="line.753">                continue; // loop back up and try to complete the new future</a>
+<span class="sourceLineNo">754</span><a id="line.754">              }</a>
+<span class="sourceLineNo">755</span><a id="line.755">            } else {</a>
+<span class="sourceLineNo">756</span><a id="line.756">              // not a TrustedFuture, call cancel directly.</a>
+<span class="sourceLineNo">757</span><a id="line.757">              futureToPropagateTo.cancel(mayInterruptIfRunning);</a>
+<span class="sourceLineNo">758</span><a id="line.758">            }</a>
+<span class="sourceLineNo">759</span><a id="line.759">          }</a>
+<span class="sourceLineNo">760</span><a id="line.760">          break;</a>
+<span class="sourceLineNo">761</span><a id="line.761">        }</a>
+<span class="sourceLineNo">762</span><a id="line.762">        // obj changed, reread</a>
+<span class="sourceLineNo">763</span><a id="line.763">        localValue = abstractFuture.value;</a>
+<span class="sourceLineNo">764</span><a id="line.764">        if (!(localValue instanceof SetFuture)) {</a>
+<span class="sourceLineNo">765</span><a id="line.765">          // obj cannot be null at this point, because value can only change from null to non-null.</a>
+<span class="sourceLineNo">766</span><a id="line.766">          // So if value changed (and it did since we lost the CAS), then it cannot be null and</a>
+<span class="sourceLineNo">767</span><a id="line.767">          // since it isn't a SetFuture, then the future must be done and we should exit the loop</a>
+<span class="sourceLineNo">768</span><a id="line.768">          break;</a>
+<span class="sourceLineNo">769</span><a id="line.769">        }</a>
+<span class="sourceLineNo">770</span><a id="line.770">      }</a>
+<span class="sourceLineNo">771</span><a id="line.771">    }</a>
+<span class="sourceLineNo">772</span><a id="line.772">    return rValue;</a>
+<span class="sourceLineNo">773</span><a id="line.773">  }</a>
+<span class="sourceLineNo">774</span><a id="line.774"></a>
+<span class="sourceLineNo">775</span><a id="line.775">  /**</a>
+<span class="sourceLineNo">776</span><a id="line.776">   * Subclasses can override this method to implement interruption of the future's computation. The</a>
+<span class="sourceLineNo">777</span><a id="line.777">   * method is invoked automatically by a successful call to {@link #cancel(boolean) cancel(true)}.</a>
+<span class="sourceLineNo">778</span><a id="line.778">   *</a>
+<span class="sourceLineNo">779</span><a id="line.779">   * &lt;p&gt;The default implementation does nothing.</a>
+<span class="sourceLineNo">780</span><a id="line.780">   *</a>
+<span class="sourceLineNo">781</span><a id="line.781">   * &lt;p&gt;This method is likely to be deprecated. Prefer to override {@link #afterDone}, checking</a>
+<span class="sourceLineNo">782</span><a id="line.782">   * {@link #wasInterrupted} to decide whether to interrupt your task.</a>
+<span class="sourceLineNo">783</span><a id="line.783">   *</a>
+<span class="sourceLineNo">784</span><a id="line.784">   * @since 10.0</a>
+<span class="sourceLineNo">785</span><a id="line.785">   */</a>
+<span class="sourceLineNo">786</span><a id="line.786">  protected void interruptTask() {}</a>
+<span class="sourceLineNo">787</span><a id="line.787"></a>
+<span class="sourceLineNo">788</span><a id="line.788">  /**</a>
+<span class="sourceLineNo">789</span><a id="line.789">   * Returns true if this future was cancelled with {@code mayInterruptIfRunning} set to {@code</a>
+<span class="sourceLineNo">790</span><a id="line.790">   * true}.</a>
+<span class="sourceLineNo">791</span><a id="line.791">   *</a>
+<span class="sourceLineNo">792</span><a id="line.792">   * @since 14.0</a>
+<span class="sourceLineNo">793</span><a id="line.793">   */</a>
+<span class="sourceLineNo">794</span><a id="line.794">  protected final boolean wasInterrupted() {</a>
+<span class="sourceLineNo">795</span><a id="line.795">    @RetainedLocalRef Object localValue = value;</a>
+<span class="sourceLineNo">796</span><a id="line.796">    return (localValue instanceof Cancellation) &amp;&amp; ((Cancellation) localValue).wasInterrupted;</a>
+<span class="sourceLineNo">797</span><a id="line.797">  }</a>
+<span class="sourceLineNo">798</span><a id="line.798"></a>
+<span class="sourceLineNo">799</span><a id="line.799">  /**</a>
+<span class="sourceLineNo">800</span><a id="line.800">   * {@inheritDoc}</a>
+<span class="sourceLineNo">801</span><a id="line.801">   *</a>
+<span class="sourceLineNo">802</span><a id="line.802">   * @since 10.0</a>
+<span class="sourceLineNo">803</span><a id="line.803">   */</a>
+<span class="sourceLineNo">804</span><a id="line.804">  @Override</a>
+<span class="sourceLineNo">805</span><a id="line.805">  public void addListener(Runnable listener, Executor executor) {</a>
+<span class="sourceLineNo">806</span><a id="line.806">    checkNotNull(listener, "Runnable was null.");</a>
+<span class="sourceLineNo">807</span><a id="line.807">    checkNotNull(executor, "Executor was null.");</a>
+<span class="sourceLineNo">808</span><a id="line.808">    // Checking isDone and listeners != TOMBSTONE may seem redundant, but our contract for</a>
+<span class="sourceLineNo">809</span><a id="line.809">    // addListener says that listeners execute 'immediate' if the future isDone(). However, our</a>
+<span class="sourceLineNo">810</span><a id="line.810">    // protocol for completing a future is to assign the value field (which sets isDone to true) and</a>
+<span class="sourceLineNo">811</span><a id="line.811">    // then to release waiters, followed by executing afterDone(), followed by releasing listeners.</a>
+<span class="sourceLineNo">812</span><a id="line.812">    // That means that it is possible to observe that the future isDone and that your listeners</a>
+<span class="sourceLineNo">813</span><a id="line.813">    // don't execute 'immediately'.  By checking isDone here we avoid that.</a>
+<span class="sourceLineNo">814</span><a id="line.814">    // A corollary to all that is that we don't need to check isDone inside the loop because if we</a>
+<span class="sourceLineNo">815</span><a id="line.815">    // get into the loop we know that we weren't done when we entered and therefore we aren't under</a>
+<span class="sourceLineNo">816</span><a id="line.816">    // an obligation to execute 'immediately'.</a>
+<span class="sourceLineNo">817</span><a id="line.817">    if (!isDone()) {</a>
+<span class="sourceLineNo">818</span><a id="line.818">      Listener oldHead = listeners;</a>
+<span class="sourceLineNo">819</span><a id="line.819">      if (oldHead != Listener.TOMBSTONE) {</a>
+<span class="sourceLineNo">820</span><a id="line.820">        Listener newNode = new Listener(listener, executor);</a>
+<span class="sourceLineNo">821</span><a id="line.821">        do {</a>
+<span class="sourceLineNo">822</span><a id="line.822">          newNode.next = oldHead;</a>
+<span class="sourceLineNo">823</span><a id="line.823">          if (ATOMIC_HELPER.casListeners(this, oldHead, newNode)) {</a>
+<span class="sourceLineNo">824</span><a id="line.824">            return;</a>
+<span class="sourceLineNo">825</span><a id="line.825">          }</a>
+<span class="sourceLineNo">826</span><a id="line.826">          oldHead = listeners; // re-read</a>
+<span class="sourceLineNo">827</span><a id="line.827">        } while (oldHead != Listener.TOMBSTONE);</a>
+<span class="sourceLineNo">828</span><a id="line.828">      }</a>
+<span class="sourceLineNo">829</span><a id="line.829">    }</a>
+<span class="sourceLineNo">830</span><a id="line.830">    // If we get here then the Listener TOMBSTONE was set, which means the future is done, call</a>
+<span class="sourceLineNo">831</span><a id="line.831">    // the listener.</a>
+<span class="sourceLineNo">832</span><a id="line.832">    executeListener(listener, executor);</a>
+<span class="sourceLineNo">833</span><a id="line.833">  }</a>
+<span class="sourceLineNo">834</span><a id="line.834"></a>
+<span class="sourceLineNo">835</span><a id="line.835">  /**</a>
+<span class="sourceLineNo">836</span><a id="line.836">   * Sets the result of this {@code Future} unless this {@code Future} has already been cancelled or</a>
+<span class="sourceLineNo">837</span><a id="line.837">   * set (including {@linkplain #setFuture set asynchronously}). When a call to this method returns,</a>
+<span class="sourceLineNo">838</span><a id="line.838">   * the {@code Future} is guaranteed to be {@linkplain #isDone done} &lt;b&gt;only if&lt;/b&gt; the call was</a>
+<span class="sourceLineNo">839</span><a id="line.839">   * accepted (in which case it returns {@code true}). If it returns {@code false}, the {@code</a>
+<span class="sourceLineNo">840</span><a id="line.840">   * Future} may have previously been set asynchronously, in which case its result may not be known</a>
+<span class="sourceLineNo">841</span><a id="line.841">   * yet. That result, though not yet known, cannot be overridden by a call to a {@code set*}</a>
+<span class="sourceLineNo">842</span><a id="line.842">   * method, only by a call to {@link #cancel}.</a>
 <span class="sourceLineNo">843</span><a id="line.843">   *</a>
 <span class="sourceLineNo">844</span><a id="line.844">   * &lt;p&gt;Beware of completing a future while holding a lock. Its listeners may do slow work or</a>
 <span class="sourceLineNo">845</span><a id="line.845">   * acquire other locks, risking deadlocks.</a>
 <span class="sourceLineNo">846</span><a id="line.846">   *</a>
-<span class="sourceLineNo">847</span><a id="line.847">   * @param future the future to delegate to</a>
-<span class="sourceLineNo">848</span><a id="line.848">   * @return true if the attempt was accepted, indicating that the {@code Future} was not previously</a>
-<span class="sourceLineNo">849</span><a id="line.849">   *     cancelled or set.</a>
-<span class="sourceLineNo">850</span><a id="line.850">   * @since 19.0</a>
-<span class="sourceLineNo">851</span><a id="line.851">   */</a>
-<span class="sourceLineNo">852</span><a id="line.852">  @CanIgnoreReturnValue</a>
-<span class="sourceLineNo">853</span><a id="line.853">  @SuppressWarnings("Interruption") // We are propagating an interrupt from a caller.</a>
-<span class="sourceLineNo">854</span><a id="line.854">  protected boolean setFuture(ListenableFuture&lt;? extends V&gt; future) {</a>
-<span class="sourceLineNo">855</span><a id="line.855">    checkNotNull(future);</a>
-<span class="sourceLineNo">856</span><a id="line.856">    @RetainedLocalRef Object localValue = value;</a>
-<span class="sourceLineNo">857</span><a id="line.857">    if (localValue == null) {</a>
-<span class="sourceLineNo">858</span><a id="line.858">      if (future.isDone()) {</a>
-<span class="sourceLineNo">859</span><a id="line.859">        Object value = getFutureValue(future);</a>
-<span class="sourceLineNo">860</span><a id="line.860">        if (ATOMIC_HELPER.casValue(this, null, value)) {</a>
-<span class="sourceLineNo">861</span><a id="line.861">          complete(</a>
-<span class="sourceLineNo">862</span><a id="line.862">              this,</a>
-<span class="sourceLineNo">863</span><a id="line.863">              /*</a>
-<span class="sourceLineNo">864</span><a id="line.864">               * Interruption doesn't propagate through a SetFuture chain (see getFutureValue), so</a>
-<span class="sourceLineNo">865</span><a id="line.865">               * don't invoke interruptTask.</a>
-<span class="sourceLineNo">866</span><a id="line.866">               */</a>
-<span class="sourceLineNo">867</span><a id="line.867">              false);</a>
-<span class="sourceLineNo">868</span><a id="line.868">          return true;</a>
-<span class="sourceLineNo">869</span><a id="line.869">        }</a>
-<span class="sourceLineNo">870</span><a id="line.870">        return false;</a>
-<span class="sourceLineNo">871</span><a id="line.871">      }</a>
-<span class="sourceLineNo">872</span><a id="line.872">      SetFuture&lt;V&gt; valueToSet = new SetFuture&lt;&gt;(this, future);</a>
-<span class="sourceLineNo">873</span><a id="line.873">      if (ATOMIC_HELPER.casValue(this, null, valueToSet)) {</a>
-<span class="sourceLineNo">874</span><a id="line.874">        // the listener is responsible for calling completeWithFuture, directExecutor is appropriate</a>
-<span class="sourceLineNo">875</span><a id="line.875">        // since all we are doing is unpacking a completed future which should be fast.</a>
-<span class="sourceLineNo">876</span><a id="line.876">        try {</a>
-<span class="sourceLineNo">877</span><a id="line.877">          future.addListener(valueToSet, DirectExecutor.INSTANCE);</a>
-<span class="sourceLineNo">878</span><a id="line.878">        } catch (Throwable t) {</a>
-<span class="sourceLineNo">879</span><a id="line.879">          // Any Exception is either a RuntimeException or sneaky checked exception.</a>
-<span class="sourceLineNo">880</span><a id="line.880">          //</a>
-<span class="sourceLineNo">881</span><a id="line.881">          // addListener has thrown an exception! SetFuture.run can't throw any exceptions so this</a>
-<span class="sourceLineNo">882</span><a id="line.882">          // must have been caused by addListener itself. The most likely explanation is a</a>
-<span class="sourceLineNo">883</span><a id="line.883">          // misconfigured mock. Try to switch to Failure.</a>
-<span class="sourceLineNo">884</span><a id="line.884">          Failure failure;</a>
-<span class="sourceLineNo">885</span><a id="line.885">          try {</a>
-<span class="sourceLineNo">886</span><a id="line.886">            failure = new Failure(t);</a>
-<span class="sourceLineNo">887</span><a id="line.887">          } catch (Exception | Error oomMostLikely) { // sneaky checked exception</a>
-<span class="sourceLineNo">888</span><a id="line.888">            failure = Failure.FALLBACK_INSTANCE;</a>
-<span class="sourceLineNo">889</span><a id="line.889">          }</a>
-<span class="sourceLineNo">890</span><a id="line.890">          // Note: The only way this CAS could fail is if cancel() has raced with us. That is ok.</a>
-<span class="sourceLineNo">891</span><a id="line.891">          boolean unused = ATOMIC_HELPER.casValue(this, valueToSet, failure);</a>
-<span class="sourceLineNo">892</span><a id="line.892">        }</a>
-<span class="sourceLineNo">893</span><a id="line.893">        return true;</a>
-<span class="sourceLineNo">894</span><a id="line.894">      }</a>
-<span class="sourceLineNo">895</span><a id="line.895">      localValue = value; // we lost the cas, fall through and maybe cancel</a>
-<span class="sourceLineNo">896</span><a id="line.896">    }</a>
-<span class="sourceLineNo">897</span><a id="line.897">    // The future has already been set to something. If it is cancellation we should cancel the</a>
-<span class="sourceLineNo">898</span><a id="line.898">    // incoming future.</a>
-<span class="sourceLineNo">899</span><a id="line.899">    if (localValue instanceof Cancellation) {</a>
-<span class="sourceLineNo">900</span><a id="line.900">      // we don't care if it fails, this is best-effort.</a>
-<span class="sourceLineNo">901</span><a id="line.901">      future.cancel(((Cancellation) localValue).wasInterrupted);</a>
-<span class="sourceLineNo">902</span><a id="line.902">    }</a>
-<span class="sourceLineNo">903</span><a id="line.903">    return false;</a>
-<span class="sourceLineNo">904</span><a id="line.904">  }</a>
-<span class="sourceLineNo">905</span><a id="line.905"></a>
-<span class="sourceLineNo">906</span><a id="line.906">  /**</a>
-<span class="sourceLineNo">907</span><a id="line.907">   * Returns a value that satisfies the contract of the {@link #value} field based on the state of</a>
-<span class="sourceLineNo">908</span><a id="line.908">   * given future.</a>
-<span class="sourceLineNo">909</span><a id="line.909">   *</a>
-<span class="sourceLineNo">910</span><a id="line.910">   * &lt;p&gt;This is approximately the inverse of {@link #getDoneValue(Object)}</a>
-<span class="sourceLineNo">911</span><a id="line.911">   */</a>
-<span class="sourceLineNo">912</span><a id="line.912">  private static Object getFutureValue(ListenableFuture&lt;?&gt; future) {</a>
-<span class="sourceLineNo">913</span><a id="line.913">    if (future instanceof Trusted) {</a>
-<span class="sourceLineNo">914</span><a id="line.914">      // Break encapsulation for TrustedFuture instances since we know that subclasses cannot</a>
-<span class="sourceLineNo">915</span><a id="line.915">      // override .get() (since it is final) and therefore this is equivalent to calling .get()</a>
-<span class="sourceLineNo">916</span><a id="line.916">      // and unpacking the exceptions like we do below (just much faster because it is a single</a>
-<span class="sourceLineNo">917</span><a id="line.917">      // field read instead of a read, several branches and possibly creating exceptions).</a>
-<span class="sourceLineNo">918</span><a id="line.918">      Object v = ((AbstractFuture&lt;?&gt;) future).value;</a>
-<span class="sourceLineNo">919</span><a id="line.919">      if (v instanceof Cancellation) {</a>
-<span class="sourceLineNo">920</span><a id="line.920">        // If the other future was interrupted, clear the interrupted bit while preserving the cause</a>
-<span class="sourceLineNo">921</span><a id="line.921">        // this will make it consistent with how non-trustedfutures work which cannot propagate the</a>
-<span class="sourceLineNo">922</span><a id="line.922">        // wasInterrupted bit</a>
-<span class="sourceLineNo">923</span><a id="line.923">        Cancellation c = (Cancellation) v;</a>
-<span class="sourceLineNo">924</span><a id="line.924">        if (c.wasInterrupted) {</a>
-<span class="sourceLineNo">925</span><a id="line.925">          v =</a>
-<span class="sourceLineNo">926</span><a id="line.926">              c.cause != null</a>
-<span class="sourceLineNo">927</span><a id="line.927">                  ? new Cancellation(/* wasInterrupted= */ false, c.cause)</a>
-<span class="sourceLineNo">928</span><a id="line.928">                  : Cancellation.CAUSELESS_CANCELLED;</a>
-<span class="sourceLineNo">929</span><a id="line.929">        }</a>
-<span class="sourceLineNo">930</span><a id="line.930">      }</a>
-<span class="sourceLineNo">931</span><a id="line.931">      // requireNonNull is safe as long as we call this method only on completed futures.</a>
-<span class="sourceLineNo">932</span><a id="line.932">      return requireNonNull(v);</a>
-<span class="sourceLineNo">933</span><a id="line.933">    }</a>
-<span class="sourceLineNo">934</span><a id="line.934">    if (future instanceof InternalFutureFailureAccess) {</a>
-<span class="sourceLineNo">935</span><a id="line.935">      Throwable throwable =</a>
-<span class="sourceLineNo">936</span><a id="line.936">          InternalFutures.tryInternalFastPathGetFailure((InternalFutureFailureAccess) future);</a>
-<span class="sourceLineNo">937</span><a id="line.937">      if (throwable != null) {</a>
-<span class="sourceLineNo">938</span><a id="line.938">        return new Failure(throwable);</a>
-<span class="sourceLineNo">939</span><a id="line.939">      }</a>
-<span class="sourceLineNo">940</span><a id="line.940">    }</a>
-<span class="sourceLineNo">941</span><a id="line.941">    boolean wasCancelled = future.isCancelled();</a>
-<span class="sourceLineNo">942</span><a id="line.942">    // Don't allocate a CancellationException if it's not necessary</a>
-<span class="sourceLineNo">943</span><a id="line.943">    if (!GENERATE_CANCELLATION_CAUSES &amp; wasCancelled) {</a>
-<span class="sourceLineNo">944</span><a id="line.944">      /*</a>
-<span class="sourceLineNo">945</span><a id="line.945">       * requireNonNull is safe because we've initialized CAUSELESS_CANCELLED if</a>
-<span class="sourceLineNo">946</span><a id="line.946">       * !GENERATE_CANCELLATION_CAUSES.</a>
-<span class="sourceLineNo">947</span><a id="line.947">       */</a>
-<span class="sourceLineNo">948</span><a id="line.948">      return requireNonNull(Cancellation.CAUSELESS_CANCELLED);</a>
-<span class="sourceLineNo">949</span><a id="line.949">    }</a>
-<span class="sourceLineNo">950</span><a id="line.950">    // Otherwise calculate the value by calling .get()</a>
-<span class="sourceLineNo">951</span><a id="line.951">    try {</a>
-<span class="sourceLineNo">952</span><a id="line.952">      Object v = getUninterruptibly(future);</a>
-<span class="sourceLineNo">953</span><a id="line.953">      if (wasCancelled) {</a>
-<span class="sourceLineNo">954</span><a id="line.954">        return new Cancellation(</a>
-<span class="sourceLineNo">955</span><a id="line.955">            false,</a>
-<span class="sourceLineNo">956</span><a id="line.956">            new IllegalArgumentException(</a>
-<span class="sourceLineNo">957</span><a id="line.957">                "get() did not throw CancellationException, despite reporting "</a>
-<span class="sourceLineNo">958</span><a id="line.958">                    + "isCancelled() == true: "</a>
-<span class="sourceLineNo">959</span><a id="line.959">                    + future));</a>
-<span class="sourceLineNo">960</span><a id="line.960">      }</a>
-<span class="sourceLineNo">961</span><a id="line.961">      return v == null ? NULL : v;</a>
-<span class="sourceLineNo">962</span><a id="line.962">    } catch (ExecutionException exception) {</a>
-<span class="sourceLineNo">963</span><a id="line.963">      if (wasCancelled) {</a>
-<span class="sourceLineNo">964</span><a id="line.964">        return new Cancellation(</a>
-<span class="sourceLineNo">965</span><a id="line.965">            false,</a>
-<span class="sourceLineNo">966</span><a id="line.966">            new IllegalArgumentException(</a>
-<span class="sourceLineNo">967</span><a id="line.967">                "get() did not throw CancellationException, despite reporting "</a>
-<span class="sourceLineNo">968</span><a id="line.968">                    + "isCancelled() == true: "</a>
-<span class="sourceLineNo">969</span><a id="line.969">                    + future,</a>
-<span class="sourceLineNo">970</span><a id="line.970">                exception));</a>
-<span class="sourceLineNo">971</span><a id="line.971">      }</a>
-<span class="sourceLineNo">972</span><a id="line.972">      return new Failure(exception.getCause());</a>
-<span class="sourceLineNo">973</span><a id="line.973">    } catch (CancellationException cancellation) {</a>
-<span class="sourceLineNo">974</span><a id="line.974">      if (!wasCancelled) {</a>
-<span class="sourceLineNo">975</span><a id="line.975">        return new Failure(</a>
-<span class="sourceLineNo">976</span><a id="line.976">            new IllegalArgumentException(</a>
-<span class="sourceLineNo">977</span><a id="line.977">                "get() threw CancellationException, despite reporting isCancelled() == false: "</a>
-<span class="sourceLineNo">978</span><a id="line.978">                    + future,</a>
-<span class="sourceLineNo">979</span><a id="line.979">                cancellation));</a>
-<span class="sourceLineNo">980</span><a id="line.980">      }</a>
-<span class="sourceLineNo">981</span><a id="line.981">      return new Cancellation(false, cancellation);</a>
-<span class="sourceLineNo">982</span><a id="line.982">    } catch (Exception | Error t) { // sneaky checked exception</a>
-<span class="sourceLineNo">983</span><a id="line.983">      return new Failure(t);</a>
-<span class="sourceLineNo">984</span><a id="line.984">    }</a>
-<span class="sourceLineNo">985</span><a id="line.985">  }</a>
-<span class="sourceLineNo">986</span><a id="line.986"></a>
-<span class="sourceLineNo">987</span><a id="line.987">  /**</a>
-<span class="sourceLineNo">988</span><a id="line.988">   * An inlined private copy of {@link Uninterruptibles#getUninterruptibly} used to break an</a>
-<span class="sourceLineNo">989</span><a id="line.989">   * internal dependency on other /util/concurrent classes.</a>
-<span class="sourceLineNo">990</span><a id="line.990">   */</a>
-<span class="sourceLineNo">991</span><a id="line.991">  @ParametricNullness</a>
-<span class="sourceLineNo">992</span><a id="line.992">  private static &lt;V extends @Nullable Object&gt; V getUninterruptibly(Future&lt;V&gt; future)</a>
-<span class="sourceLineNo">993</span><a id="line.993">      throws ExecutionException {</a>
-<span class="sourceLineNo">994</span><a id="line.994">    boolean interrupted = false;</a>
-<span class="sourceLineNo">995</span><a id="line.995">    try {</a>
-<span class="sourceLineNo">996</span><a id="line.996">      while (true) {</a>
-<span class="sourceLineNo">997</span><a id="line.997">        try {</a>
-<span class="sourceLineNo">998</span><a id="line.998">          return future.get();</a>
-<span class="sourceLineNo">999</span><a id="line.999">        } catch (InterruptedException e) {</a>
-<span class="sourceLineNo">1000</span><a id="line.1000">          interrupted = true;</a>
-<span class="sourceLineNo">1001</span><a id="line.1001">        }</a>
-<span class="sourceLineNo">1002</span><a id="line.1002">      }</a>
-<span class="sourceLineNo">1003</span><a id="line.1003">    } finally {</a>
-<span class="sourceLineNo">1004</span><a id="line.1004">      if (interrupted) {</a>
-<span class="sourceLineNo">1005</span><a id="line.1005">        Thread.currentThread().interrupt();</a>
-<span class="sourceLineNo">1006</span><a id="line.1006">      }</a>
-<span class="sourceLineNo">1007</span><a id="line.1007">    }</a>
-<span class="sourceLineNo">1008</span><a id="line.1008">  }</a>
-<span class="sourceLineNo">1009</span><a id="line.1009"></a>
-<span class="sourceLineNo">1010</span><a id="line.1010">  /** Unblocks all threads and runs all listeners. */</a>
-<span class="sourceLineNo">1011</span><a id="line.1011">  private static void complete(AbstractFuture&lt;?&gt; param, boolean callInterruptTask) {</a>
-<span class="sourceLineNo">1012</span><a id="line.1012">    // Declare a "true" local variable so that the Checker Framework will infer nullness.</a>
-<span class="sourceLineNo">1013</span><a id="line.1013">    AbstractFuture&lt;?&gt; future = param;</a>
-<span class="sourceLineNo">1014</span><a id="line.1014"></a>
-<span class="sourceLineNo">1015</span><a id="line.1015">    Listener next = null;</a>
-<span class="sourceLineNo">1016</span><a id="line.1016">    outer:</a>
-<span class="sourceLineNo">1017</span><a id="line.1017">    while (true) {</a>
-<span class="sourceLineNo">1018</span><a id="line.1018">      future.releaseWaiters();</a>
-<span class="sourceLineNo">1019</span><a id="line.1019">      /*</a>
-<span class="sourceLineNo">1020</span><a id="line.1020">       * We call interruptTask() immediately before afterDone() so that migrating between the two</a>
-<span class="sourceLineNo">1021</span><a id="line.1021">       * can be a no-op.</a>
-<span class="sourceLineNo">1022</span><a id="line.1022">       */</a>
-<span class="sourceLineNo">1023</span><a id="line.1023">      if (callInterruptTask) {</a>
-<span class="sourceLineNo">1024</span><a id="line.1024">        future.interruptTask();</a>
-<span class="sourceLineNo">1025</span><a id="line.1025">        /*</a>
-<span class="sourceLineNo">1026</span><a id="line.1026">         * Interruption doesn't propagate through a SetFuture chain (see getFutureValue), so don't</a>
-<span class="sourceLineNo">1027</span><a id="line.1027">         * invoke interruptTask on any subsequent futures.</a>
-<span class="sourceLineNo">1028</span><a id="line.1028">         */</a>
-<span class="sourceLineNo">1029</span><a id="line.1029">        callInterruptTask = false;</a>
-<span class="sourceLineNo">1030</span><a id="line.1030">      }</a>
-<span class="sourceLineNo">1031</span><a id="line.1031">      // We call this before the listeners in order to avoid needing to manage a separate stack data</a>
-<span class="sourceLineNo">1032</span><a id="line.1032">      // structure for them.  Also, some implementations rely on this running prior to listeners</a>
-<span class="sourceLineNo">1033</span><a id="line.1033">      // so that the cleanup work is visible to listeners.</a>
-<span class="sourceLineNo">1034</span><a id="line.1034">      // afterDone() should be generally fast and only used for cleanup work... but in theory can</a>
-<span class="sourceLineNo">1035</span><a id="line.1035">      // also be recursive and create StackOverflowErrors</a>
-<span class="sourceLineNo">1036</span><a id="line.1036">      future.afterDone();</a>
-<span class="sourceLineNo">1037</span><a id="line.1037">      // push the current set of listeners onto next</a>
-<span class="sourceLineNo">1038</span><a id="line.1038">      next = future.clearListeners(next);</a>
-<span class="sourceLineNo">1039</span><a id="line.1039">      future = null;</a>
-<span class="sourceLineNo">1040</span><a id="line.1040">      while (next != null) {</a>
-<span class="sourceLineNo">1041</span><a id="line.1041">        Listener curr = next;</a>
-<span class="sourceLineNo">1042</span><a id="line.1042">        next = next.next;</a>
-<span class="sourceLineNo">1043</span><a id="line.1043">        /*</a>
-<span class="sourceLineNo">1044</span><a id="line.1044">         * requireNonNull is safe because the listener stack never contains TOMBSTONE until after</a>
-<span class="sourceLineNo">1045</span><a id="line.1045">         * clearListeners.</a>
-<span class="sourceLineNo">1046</span><a id="line.1046">         */</a>
-<span class="sourceLineNo">1047</span><a id="line.1047">        Runnable task = requireNonNull(curr.task);</a>
-<span class="sourceLineNo">1048</span><a id="line.1048">        if (task instanceof SetFuture) {</a>
-<span class="sourceLineNo">1049</span><a id="line.1049">          SetFuture&lt;?&gt; setFuture = (SetFuture&lt;?&gt;) task;</a>
-<span class="sourceLineNo">1050</span><a id="line.1050">          // We unwind setFuture specifically to avoid StackOverflowErrors in the case of long</a>
-<span class="sourceLineNo">1051</span><a id="line.1051">          // chains of SetFutures</a>
-<span class="sourceLineNo">1052</span><a id="line.1052">          // Handling this special case is important because there is no way to pass an executor to</a>
-<span class="sourceLineNo">1053</span><a id="line.1053">          // setFuture, so a user couldn't break the chain by doing this themselves.  It is also</a>
-<span class="sourceLineNo">1054</span><a id="line.1054">          // potentially common if someone writes a recursive Futures.transformAsync transformer.</a>
-<span class="sourceLineNo">1055</span><a id="line.1055">          future = setFuture.owner;</a>
-<span class="sourceLineNo">1056</span><a id="line.1056">          if (future.value == setFuture) {</a>
-<span class="sourceLineNo">1057</span><a id="line.1057">            Object valueToSet = getFutureValue(setFuture.future);</a>
-<span class="sourceLineNo">1058</span><a id="line.1058">            if (ATOMIC_HELPER.casValue(future, setFuture, valueToSet)) {</a>
-<span class="sourceLineNo">1059</span><a id="line.1059">              continue outer;</a>
-<span class="sourceLineNo">1060</span><a id="line.1060">            }</a>
-<span class="sourceLineNo">1061</span><a id="line.1061">          }</a>
-<span class="sourceLineNo">1062</span><a id="line.1062">          // otherwise the future we were trying to set is already done.</a>
-<span class="sourceLineNo">1063</span><a id="line.1063">        } else {</a>
-<span class="sourceLineNo">1064</span><a id="line.1064">          /*</a>
-<span class="sourceLineNo">1065</span><a id="line.1065">           * requireNonNull is safe because the listener stack never contains TOMBSTONE until after</a>
-<span class="sourceLineNo">1066</span><a id="line.1066">           * clearListeners.</a>
-<span class="sourceLineNo">1067</span><a id="line.1067">           */</a>
-<span class="sourceLineNo">1068</span><a id="line.1068">          executeListener(task, requireNonNull(curr.executor));</a>
-<span class="sourceLineNo">1069</span><a id="line.1069">        }</a>
-<span class="sourceLineNo">1070</span><a id="line.1070">      }</a>
-<span class="sourceLineNo">1071</span><a id="line.1071">      break;</a>
-<span class="sourceLineNo">1072</span><a id="line.1072">    }</a>
-<span class="sourceLineNo">1073</span><a id="line.1073">  }</a>
-<span class="sourceLineNo">1074</span><a id="line.1074"></a>
-<span class="sourceLineNo">1075</span><a id="line.1075">  /**</a>
-<span class="sourceLineNo">1076</span><a id="line.1076">   * Callback method that is called exactly once after the future is completed.</a>
-<span class="sourceLineNo">1077</span><a id="line.1077">   *</a>
-<span class="sourceLineNo">1078</span><a id="line.1078">   * &lt;p&gt;If {@link #interruptTask} is also run during completion, {@link #afterDone} runs after it.</a>
-<span class="sourceLineNo">1079</span><a id="line.1079">   *</a>
-<span class="sourceLineNo">1080</span><a id="line.1080">   * &lt;p&gt;The default implementation of this method in {@code AbstractFuture} does nothing. This is</a>
-<span class="sourceLineNo">1081</span><a id="line.1081">   * intended for very lightweight cleanup work, for example, timing statistics or clearing fields.</a>
-<span class="sourceLineNo">1082</span><a id="line.1082">   * If your task does anything heavier consider, just using a listener with an executor.</a>
-<span class="sourceLineNo">1083</span><a id="line.1083">   *</a>
-<span class="sourceLineNo">1084</span><a id="line.1084">   * @since 20.0</a>
-<span class="sourceLineNo">1085</span><a id="line.1085">   */</a>
-<span class="sourceLineNo">1086</span><a id="line.1086">  @ForOverride</a>
-<span class="sourceLineNo">1087</span><a id="line.1087">  protected void afterDone() {}</a>
-<span class="sourceLineNo">1088</span><a id="line.1088"></a>
-<span class="sourceLineNo">1089</span><a id="line.1089">  // TODO(b/114236866): Inherit doc from InternalFutureFailureAccess. Also, -link to its URL.</a>
-<span class="sourceLineNo">1090</span><a id="line.1090">  /**</a>
-<span class="sourceLineNo">1091</span><a id="line.1091">   * Usually returns {@code null} but, if this {@code Future} has failed, may &lt;i&gt;optionally&lt;/i&gt;</a>
-<span class="sourceLineNo">1092</span><a id="line.1092">   * return the cause of the failure. "Failure" means specifically "completed with an exception"; it</a>
-<span class="sourceLineNo">1093</span><a id="line.1093">   * does not include "was cancelled." To be explicit: If this method returns a non-null value,</a>
-<span class="sourceLineNo">1094</span><a id="line.1094">   * then:</a>
-<span class="sourceLineNo">1095</span><a id="line.1095">   *</a>
-<span class="sourceLineNo">1096</span><a id="line.1096">   * &lt;ul&gt;</a>
-<span class="sourceLineNo">1097</span><a id="line.1097">   *   &lt;li&gt;{@code isDone()} must return {@code true}</a>
-<span class="sourceLineNo">1098</span><a id="line.1098">   *   &lt;li&gt;{@code isCancelled()} must return {@code false}</a>
-<span class="sourceLineNo">1099</span><a id="line.1099">   *   &lt;li&gt;{@code get()} must not block, and it must throw an {@code ExecutionException} with the</a>
-<span class="sourceLineNo">1100</span><a id="line.1100">   *       return value of this method as its cause</a>
-<span class="sourceLineNo">1101</span><a id="line.1101">   * &lt;/ul&gt;</a>
-<span class="sourceLineNo">1102</span><a id="line.1102">   *</a>
-<span class="sourceLineNo">1103</span><a id="line.1103">   * &lt;p&gt;This method is {@code protected} so that classes like {@code</a>
-<span class="sourceLineNo">1104</span><a id="line.1104">   * com.google.common.util.concurrent.SettableFuture} do not expose it to their users as an</a>
-<span class="sourceLineNo">1105</span><a id="line.1105">   * instance method. In the unlikely event that you need to call this method, call {@link</a>
-<span class="sourceLineNo">1106</span><a id="line.1106">   * InternalFutures#tryInternalFastPathGetFailure(InternalFutureFailureAccess)}.</a>
-<span class="sourceLineNo">1107</span><a id="line.1107">   *</a>
-<span class="sourceLineNo">1108</span><a id="line.1108">   * @since 27.0</a>
-<span class="sourceLineNo">1109</span><a id="line.1109">   */</a>
-<span class="sourceLineNo">1110</span><a id="line.1110">  @Override</a>
-<span class="sourceLineNo">1111</span><a id="line.1111">  /*</a>
-<span class="sourceLineNo">1112</span><a id="line.1112">   * We should annotate the superclass, InternalFutureFailureAccess, to say that its copy of this</a>
-<span class="sourceLineNo">1113</span><a id="line.1113">   * method returns @Nullable, too. However, we're not sure if we want to make any changes to that</a>
-<span class="sourceLineNo">1114</span><a id="line.1114">   * class, since it's in a separate artifact that we planned to release only a single version of.</a>
-<span class="sourceLineNo">1115</span><a id="line.1115">   */</a>
-<span class="sourceLineNo">1116</span><a id="line.1116">  protected final @Nullable Throwable tryInternalFastPathGetFailure() {</a>
-<span class="sourceLineNo">1117</span><a id="line.1117">    if (this instanceof Trusted) {</a>
-<span class="sourceLineNo">1118</span><a id="line.1118">      @RetainedLocalRef Object localValue = value;</a>
-<span class="sourceLineNo">1119</span><a id="line.1119">      if (localValue instanceof Failure) {</a>
-<span class="sourceLineNo">1120</span><a id="line.1120">        return ((Failure) localValue).exception;</a>
-<span class="sourceLineNo">1121</span><a id="line.1121">      }</a>
-<span class="sourceLineNo">1122</span><a id="line.1122">    }</a>
-<span class="sourceLineNo">1123</span><a id="line.1123">    return null;</a>
-<span class="sourceLineNo">1124</span><a id="line.1124">  }</a>
-<span class="sourceLineNo">1125</span><a id="line.1125"></a>
-<span class="sourceLineNo">1126</span><a id="line.1126">  /**</a>
-<span class="sourceLineNo">1127</span><a id="line.1127">   * If this future has been cancelled (and possibly interrupted), cancels (and possibly interrupts)</a>
-<span class="sourceLineNo">1128</span><a id="line.1128">   * the given future (if available).</a>
-<span class="sourceLineNo">1129</span><a id="line.1129">   */</a>
-<span class="sourceLineNo">1130</span><a id="line.1130">  final void maybePropagateCancellationTo(@Nullable Future&lt;?&gt; related) {</a>
-<span class="sourceLineNo">1131</span><a id="line.1131">    if (related != null &amp; isCancelled()) {</a>
-<span class="sourceLineNo">1132</span><a id="line.1132">      related.cancel(wasInterrupted());</a>
-<span class="sourceLineNo">1133</span><a id="line.1133">    }</a>
-<span class="sourceLineNo">1134</span><a id="line.1134">  }</a>
-<span class="sourceLineNo">1135</span><a id="line.1135"></a>
-<span class="sourceLineNo">1136</span><a id="line.1136">  /** Releases all threads in the {@link #waiters} list, and clears the list. */</a>
-<span class="sourceLineNo">1137</span><a id="line.1137">  private void releaseWaiters() {</a>
-<span class="sourceLineNo">1138</span><a id="line.1138">    Waiter head = ATOMIC_HELPER.gasWaiters(this, Waiter.TOMBSTONE);</a>
-<span class="sourceLineNo">1139</span><a id="line.1139">    for (Waiter currentWaiter = head; currentWaiter != null; currentWaiter = currentWaiter.next) {</a>
-<span class="sourceLineNo">1140</span><a id="line.1140">      currentWaiter.unpark();</a>
-<span class="sourceLineNo">1141</span><a id="line.1141">    }</a>
-<span class="sourceLineNo">1142</span><a id="line.1142">  }</a>
-<span class="sourceLineNo">1143</span><a id="line.1143"></a>
-<span class="sourceLineNo">1144</span><a id="line.1144">  /**</a>
-<span class="sourceLineNo">1145</span><a id="line.1145">   * Clears the {@link #listeners} list and prepends its contents to {@code onto}, least recently</a>
-<span class="sourceLineNo">1146</span><a id="line.1146">   * added first.</a>
+<span class="sourceLineNo">847</span><a id="line.847">   * @param value the value to be used as the result</a>
+<span class="sourceLineNo">848</span><a id="line.848">   * @return true if the attempt was accepted, completing the {@code Future}</a>
+<span class="sourceLineNo">849</span><a id="line.849">   */</a>
+<span class="sourceLineNo">850</span><a id="line.850">  @CanIgnoreReturnValue</a>
+<span class="sourceLineNo">851</span><a id="line.851">  protected boolean set(@ParametricNullness V value) {</a>
+<span class="sourceLineNo">852</span><a id="line.852">    Object valueToSet = value == null ? NULL : value;</a>
+<span class="sourceLineNo">853</span><a id="line.853">    if (ATOMIC_HELPER.casValue(this, null, valueToSet)) {</a>
+<span class="sourceLineNo">854</span><a id="line.854">      complete(this, /*callInterruptTask=*/ false);</a>
+<span class="sourceLineNo">855</span><a id="line.855">      return true;</a>
+<span class="sourceLineNo">856</span><a id="line.856">    }</a>
+<span class="sourceLineNo">857</span><a id="line.857">    return false;</a>
+<span class="sourceLineNo">858</span><a id="line.858">  }</a>
+<span class="sourceLineNo">859</span><a id="line.859"></a>
+<span class="sourceLineNo">860</span><a id="line.860">  /**</a>
+<span class="sourceLineNo">861</span><a id="line.861">   * Sets the failed result of this {@code Future} unless this {@code Future} has already been</a>
+<span class="sourceLineNo">862</span><a id="line.862">   * cancelled or set (including {@linkplain #setFuture set asynchronously}). When a call to this</a>
+<span class="sourceLineNo">863</span><a id="line.863">   * method returns, the {@code Future} is guaranteed to be {@linkplain #isDone done} &lt;b&gt;only if&lt;/b&gt;</a>
+<span class="sourceLineNo">864</span><a id="line.864">   * the call was accepted (in which case it returns {@code true}). If it returns {@code false}, the</a>
+<span class="sourceLineNo">865</span><a id="line.865">   * {@code Future} may have previously been set asynchronously, in which case its result may not be</a>
+<span class="sourceLineNo">866</span><a id="line.866">   * known yet. That result, though not yet known, cannot be overridden by a call to a {@code set*}</a>
+<span class="sourceLineNo">867</span><a id="line.867">   * method, only by a call to {@link #cancel}.</a>
+<span class="sourceLineNo">868</span><a id="line.868">   *</a>
+<span class="sourceLineNo">869</span><a id="line.869">   * &lt;p&gt;Beware of completing a future while holding a lock. Its listeners may do slow work or</a>
+<span class="sourceLineNo">870</span><a id="line.870">   * acquire other locks, risking deadlocks.</a>
+<span class="sourceLineNo">871</span><a id="line.871">   *</a>
+<span class="sourceLineNo">872</span><a id="line.872">   * @param throwable the exception to be used as the failed result</a>
+<span class="sourceLineNo">873</span><a id="line.873">   * @return true if the attempt was accepted, completing the {@code Future}</a>
+<span class="sourceLineNo">874</span><a id="line.874">   */</a>
+<span class="sourceLineNo">875</span><a id="line.875">  @CanIgnoreReturnValue</a>
+<span class="sourceLineNo">876</span><a id="line.876">  protected boolean setException(Throwable throwable) {</a>
+<span class="sourceLineNo">877</span><a id="line.877">    Object valueToSet = new Failure(checkNotNull(throwable));</a>
+<span class="sourceLineNo">878</span><a id="line.878">    if (ATOMIC_HELPER.casValue(this, null, valueToSet)) {</a>
+<span class="sourceLineNo">879</span><a id="line.879">      complete(this, /*callInterruptTask=*/ false);</a>
+<span class="sourceLineNo">880</span><a id="line.880">      return true;</a>
+<span class="sourceLineNo">881</span><a id="line.881">    }</a>
+<span class="sourceLineNo">882</span><a id="line.882">    return false;</a>
+<span class="sourceLineNo">883</span><a id="line.883">  }</a>
+<span class="sourceLineNo">884</span><a id="line.884"></a>
+<span class="sourceLineNo">885</span><a id="line.885">  /**</a>
+<span class="sourceLineNo">886</span><a id="line.886">   * Sets the result of this {@code Future} to match the supplied input {@code Future} once the</a>
+<span class="sourceLineNo">887</span><a id="line.887">   * supplied {@code Future} is done, unless this {@code Future} has already been cancelled or set</a>
+<span class="sourceLineNo">888</span><a id="line.888">   * (including "set asynchronously," defined below).</a>
+<span class="sourceLineNo">889</span><a id="line.889">   *</a>
+<span class="sourceLineNo">890</span><a id="line.890">   * &lt;p&gt;If the supplied future is {@linkplain #isDone done} when this method is called and the call</a>
+<span class="sourceLineNo">891</span><a id="line.891">   * is accepted, then this future is guaranteed to have been completed with the supplied future by</a>
+<span class="sourceLineNo">892</span><a id="line.892">   * the time this method returns. If the supplied future is not done and the call is accepted, then</a>
+<span class="sourceLineNo">893</span><a id="line.893">   * the future will be &lt;i&gt;set asynchronously&lt;/i&gt;. Note that such a result, though not yet known,</a>
+<span class="sourceLineNo">894</span><a id="line.894">   * cannot be overridden by a call to a {@code set*} method, only by a call to {@link #cancel}.</a>
+<span class="sourceLineNo">895</span><a id="line.895">   *</a>
+<span class="sourceLineNo">896</span><a id="line.896">   * &lt;p&gt;If the call {@code setFuture(delegate)} is accepted and this {@code Future} is later</a>
+<span class="sourceLineNo">897</span><a id="line.897">   * cancelled, cancellation will be propagated to {@code delegate}. Additionally, any call to</a>
+<span class="sourceLineNo">898</span><a id="line.898">   * {@code setFuture} after any cancellation will propagate cancellation to the supplied {@code</a>
+<span class="sourceLineNo">899</span><a id="line.899">   * Future}.</a>
+<span class="sourceLineNo">900</span><a id="line.900">   *</a>
+<span class="sourceLineNo">901</span><a id="line.901">   * &lt;p&gt;Note that, even if the supplied future is cancelled and it causes this future to complete,</a>
+<span class="sourceLineNo">902</span><a id="line.902">   * it will never trigger interruption behavior. In particular, it will not cause this future to</a>
+<span class="sourceLineNo">903</span><a id="line.903">   * invoke the {@link #interruptTask} method, and the {@link #wasInterrupted} method will not</a>
+<span class="sourceLineNo">904</span><a id="line.904">   * return {@code true}.</a>
+<span class="sourceLineNo">905</span><a id="line.905">   *</a>
+<span class="sourceLineNo">906</span><a id="line.906">   * &lt;p&gt;Beware of completing a future while holding a lock. Its listeners may do slow work or</a>
+<span class="sourceLineNo">907</span><a id="line.907">   * acquire other locks, risking deadlocks.</a>
+<span class="sourceLineNo">908</span><a id="line.908">   *</a>
+<span class="sourceLineNo">909</span><a id="line.909">   * @param future the future to delegate to</a>
+<span class="sourceLineNo">910</span><a id="line.910">   * @return true if the attempt was accepted, indicating that the {@code Future} was not previously</a>
+<span class="sourceLineNo">911</span><a id="line.911">   *     cancelled or set.</a>
+<span class="sourceLineNo">912</span><a id="line.912">   * @since 19.0</a>
+<span class="sourceLineNo">913</span><a id="line.913">   */</a>
+<span class="sourceLineNo">914</span><a id="line.914">  @CanIgnoreReturnValue</a>
+<span class="sourceLineNo">915</span><a id="line.915">  @SuppressWarnings("Interruption") // We are propagating an interrupt from a caller.</a>
+<span class="sourceLineNo">916</span><a id="line.916">  protected boolean setFuture(ListenableFuture&lt;? extends V&gt; future) {</a>
+<span class="sourceLineNo">917</span><a id="line.917">    checkNotNull(future);</a>
+<span class="sourceLineNo">918</span><a id="line.918">    @RetainedLocalRef Object localValue = value;</a>
+<span class="sourceLineNo">919</span><a id="line.919">    if (localValue == null) {</a>
+<span class="sourceLineNo">920</span><a id="line.920">      if (future.isDone()) {</a>
+<span class="sourceLineNo">921</span><a id="line.921">        Object value = getFutureValue(future);</a>
+<span class="sourceLineNo">922</span><a id="line.922">        if (ATOMIC_HELPER.casValue(this, null, value)) {</a>
+<span class="sourceLineNo">923</span><a id="line.923">          complete(</a>
+<span class="sourceLineNo">924</span><a id="line.924">              this,</a>
+<span class="sourceLineNo">925</span><a id="line.925">              /*</a>
+<span class="sourceLineNo">926</span><a id="line.926">               * Interruption doesn't propagate through a SetFuture chain (see getFutureValue), so</a>
+<span class="sourceLineNo">927</span><a id="line.927">               * don't invoke interruptTask.</a>
+<span class="sourceLineNo">928</span><a id="line.928">               */</a>
+<span class="sourceLineNo">929</span><a id="line.929">              false);</a>
+<span class="sourceLineNo">930</span><a id="line.930">          return true;</a>
+<span class="sourceLineNo">931</span><a id="line.931">        }</a>
+<span class="sourceLineNo">932</span><a id="line.932">        return false;</a>
+<span class="sourceLineNo">933</span><a id="line.933">      }</a>
+<span class="sourceLineNo">934</span><a id="line.934">      SetFuture&lt;V&gt; valueToSet = new SetFuture&lt;&gt;(this, future);</a>
+<span class="sourceLineNo">935</span><a id="line.935">      if (ATOMIC_HELPER.casValue(this, null, valueToSet)) {</a>
+<span class="sourceLineNo">936</span><a id="line.936">        // the listener is responsible for calling completeWithFuture, directExecutor is appropriate</a>
+<span class="sourceLineNo">937</span><a id="line.937">        // since all we are doing is unpacking a completed future which should be fast.</a>
+<span class="sourceLineNo">938</span><a id="line.938">        try {</a>
+<span class="sourceLineNo">939</span><a id="line.939">          future.addListener(valueToSet, DirectExecutor.INSTANCE);</a>
+<span class="sourceLineNo">940</span><a id="line.940">        } catch (Throwable t) {</a>
+<span class="sourceLineNo">941</span><a id="line.941">          // Any Exception is either a RuntimeException or sneaky checked exception.</a>
+<span class="sourceLineNo">942</span><a id="line.942">          //</a>
+<span class="sourceLineNo">943</span><a id="line.943">          // addListener has thrown an exception! SetFuture.run can't throw any exceptions so this</a>
+<span class="sourceLineNo">944</span><a id="line.944">          // must have been caused by addListener itself. The most likely explanation is a</a>
+<span class="sourceLineNo">945</span><a id="line.945">          // misconfigured mock. Try to switch to Failure.</a>
+<span class="sourceLineNo">946</span><a id="line.946">          Failure failure;</a>
+<span class="sourceLineNo">947</span><a id="line.947">          try {</a>
+<span class="sourceLineNo">948</span><a id="line.948">            failure = new Failure(t);</a>
+<span class="sourceLineNo">949</span><a id="line.949">          } catch (Exception | Error oomMostLikely) { // sneaky checked exception</a>
+<span class="sourceLineNo">950</span><a id="line.950">            failure = Failure.FALLBACK_INSTANCE;</a>
+<span class="sourceLineNo">951</span><a id="line.951">          }</a>
+<span class="sourceLineNo">952</span><a id="line.952">          // Note: The only way this CAS could fail is if cancel() has raced with us. That is ok.</a>
+<span class="sourceLineNo">953</span><a id="line.953">          boolean unused = ATOMIC_HELPER.casValue(this, valueToSet, failure);</a>
+<span class="sourceLineNo">954</span><a id="line.954">        }</a>
+<span class="sourceLineNo">955</span><a id="line.955">        return true;</a>
+<span class="sourceLineNo">956</span><a id="line.956">      }</a>
+<span class="sourceLineNo">957</span><a id="line.957">      localValue = value; // we lost the cas, fall through and maybe cancel</a>
+<span class="sourceLineNo">958</span><a id="line.958">    }</a>
+<span class="sourceLineNo">959</span><a id="line.959">    // The future has already been set to something. If it is cancellation we should cancel the</a>
+<span class="sourceLineNo">960</span><a id="line.960">    // incoming future.</a>
+<span class="sourceLineNo">961</span><a id="line.961">    if (localValue instanceof Cancellation) {</a>
+<span class="sourceLineNo">962</span><a id="line.962">      // we don't care if it fails, this is best-effort.</a>
+<span class="sourceLineNo">963</span><a id="line.963">      future.cancel(((Cancellation) localValue).wasInterrupted);</a>
+<span class="sourceLineNo">964</span><a id="line.964">    }</a>
+<span class="sourceLineNo">965</span><a id="line.965">    return false;</a>
+<span class="sourceLineNo">966</span><a id="line.966">  }</a>
+<span class="sourceLineNo">967</span><a id="line.967"></a>
+<span class="sourceLineNo">968</span><a id="line.968">  /**</a>
+<span class="sourceLineNo">969</span><a id="line.969">   * Returns a value that satisfies the contract of the {@link #value} field based on the state of</a>
+<span class="sourceLineNo">970</span><a id="line.970">   * given future.</a>
+<span class="sourceLineNo">971</span><a id="line.971">   *</a>
+<span class="sourceLineNo">972</span><a id="line.972">   * &lt;p&gt;This is approximately the inverse of {@link #getDoneValue(Object)}</a>
+<span class="sourceLineNo">973</span><a id="line.973">   */</a>
+<span class="sourceLineNo">974</span><a id="line.974">  private static Object getFutureValue(ListenableFuture&lt;?&gt; future) {</a>
+<span class="sourceLineNo">975</span><a id="line.975">    if (future instanceof Trusted) {</a>
+<span class="sourceLineNo">976</span><a id="line.976">      // Break encapsulation for TrustedFuture instances since we know that subclasses cannot</a>
+<span class="sourceLineNo">977</span><a id="line.977">      // override .get() (since it is final) and therefore this is equivalent to calling .get()</a>
+<span class="sourceLineNo">978</span><a id="line.978">      // and unpacking the exceptions like we do below (just much faster because it is a single</a>
+<span class="sourceLineNo">979</span><a id="line.979">      // field read instead of a read, several branches and possibly creating exceptions).</a>
+<span class="sourceLineNo">980</span><a id="line.980">      Object v = ((AbstractFuture&lt;?&gt;) future).value;</a>
+<span class="sourceLineNo">981</span><a id="line.981">      if (v instanceof Cancellation) {</a>
+<span class="sourceLineNo">982</span><a id="line.982">        // If the other future was interrupted, clear the interrupted bit while preserving the cause</a>
+<span class="sourceLineNo">983</span><a id="line.983">        // this will make it consistent with how non-trustedfutures work which cannot propagate the</a>
+<span class="sourceLineNo">984</span><a id="line.984">        // wasInterrupted bit</a>
+<span class="sourceLineNo">985</span><a id="line.985">        Cancellation c = (Cancellation) v;</a>
+<span class="sourceLineNo">986</span><a id="line.986">        if (c.wasInterrupted) {</a>
+<span class="sourceLineNo">987</span><a id="line.987">          v =</a>
+<span class="sourceLineNo">988</span><a id="line.988">              c.cause != null</a>
+<span class="sourceLineNo">989</span><a id="line.989">                  ? new Cancellation(/* wasInterrupted= */ false, c.cause)</a>
+<span class="sourceLineNo">990</span><a id="line.990">                  : Cancellation.CAUSELESS_CANCELLED;</a>
+<span class="sourceLineNo">991</span><a id="line.991">        }</a>
+<span class="sourceLineNo">992</span><a id="line.992">      }</a>
+<span class="sourceLineNo">993</span><a id="line.993">      // requireNonNull is safe as long as we call this method only on completed futures.</a>
+<span class="sourceLineNo">994</span><a id="line.994">      return requireNonNull(v);</a>
+<span class="sourceLineNo">995</span><a id="line.995">    }</a>
+<span class="sourceLineNo">996</span><a id="line.996">    if (future instanceof InternalFutureFailureAccess) {</a>
+<span class="sourceLineNo">997</span><a id="line.997">      Throwable throwable =</a>
+<span class="sourceLineNo">998</span><a id="line.998">          InternalFutures.tryInternalFastPathGetFailure((InternalFutureFailureAccess) future);</a>
+<span class="sourceLineNo">999</span><a id="line.999">      if (throwable != null) {</a>
+<span class="sourceLineNo">1000</span><a id="line.1000">        return new Failure(throwable);</a>
+<span class="sourceLineNo">1001</span><a id="line.1001">      }</a>
+<span class="sourceLineNo">1002</span><a id="line.1002">    }</a>
+<span class="sourceLineNo">1003</span><a id="line.1003">    boolean wasCancelled = future.isCancelled();</a>
+<span class="sourceLineNo">1004</span><a id="line.1004">    // Don't allocate a CancellationException if it's not necessary</a>
+<span class="sourceLineNo">1005</span><a id="line.1005">    if (!GENERATE_CANCELLATION_CAUSES &amp; wasCancelled) {</a>
+<span class="sourceLineNo">1006</span><a id="line.1006">      /*</a>
+<span class="sourceLineNo">1007</span><a id="line.1007">       * requireNonNull is safe because we've initialized CAUSELESS_CANCELLED if</a>
+<span class="sourceLineNo">1008</span><a id="line.1008">       * !GENERATE_CANCELLATION_CAUSES.</a>
+<span class="sourceLineNo">1009</span><a id="line.1009">       */</a>
+<span class="sourceLineNo">1010</span><a id="line.1010">      return requireNonNull(Cancellation.CAUSELESS_CANCELLED);</a>
+<span class="sourceLineNo">1011</span><a id="line.1011">    }</a>
+<span class="sourceLineNo">1012</span><a id="line.1012">    // Otherwise calculate the value by calling .get()</a>
+<span class="sourceLineNo">1013</span><a id="line.1013">    try {</a>
+<span class="sourceLineNo">1014</span><a id="line.1014">      Object v = getUninterruptibly(future);</a>
+<span class="sourceLineNo">1015</span><a id="line.1015">      if (wasCancelled) {</a>
+<span class="sourceLineNo">1016</span><a id="line.1016">        return new Cancellation(</a>
+<span class="sourceLineNo">1017</span><a id="line.1017">            false,</a>
+<span class="sourceLineNo">1018</span><a id="line.1018">            new IllegalArgumentException(</a>
+<span class="sourceLineNo">1019</span><a id="line.1019">                "get() did not throw CancellationException, despite reporting "</a>
+<span class="sourceLineNo">1020</span><a id="line.1020">                    + "isCancelled() == true: "</a>
+<span class="sourceLineNo">1021</span><a id="line.1021">                    + future));</a>
+<span class="sourceLineNo">1022</span><a id="line.1022">      }</a>
+<span class="sourceLineNo">1023</span><a id="line.1023">      return v == null ? NULL : v;</a>
+<span class="sourceLineNo">1024</span><a id="line.1024">    } catch (ExecutionException exception) {</a>
+<span class="sourceLineNo">1025</span><a id="line.1025">      if (wasCancelled) {</a>
+<span class="sourceLineNo">1026</span><a id="line.1026">        return new Cancellation(</a>
+<span class="sourceLineNo">1027</span><a id="line.1027">            false,</a>
+<span class="sourceLineNo">1028</span><a id="line.1028">            new IllegalArgumentException(</a>
+<span class="sourceLineNo">1029</span><a id="line.1029">                "get() did not throw CancellationException, despite reporting "</a>
+<span class="sourceLineNo">1030</span><a id="line.1030">                    + "isCancelled() == true: "</a>
+<span class="sourceLineNo">1031</span><a id="line.1031">                    + future,</a>
+<span class="sourceLineNo">1032</span><a id="line.1032">                exception));</a>
+<span class="sourceLineNo">1033</span><a id="line.1033">      }</a>
+<span class="sourceLineNo">1034</span><a id="line.1034">      return new Failure(exception.getCause());</a>
+<span class="sourceLineNo">1035</span><a id="line.1035">    } catch (CancellationException cancellation) {</a>
+<span class="sourceLineNo">1036</span><a id="line.1036">      if (!wasCancelled) {</a>
+<span class="sourceLineNo">1037</span><a id="line.1037">        return new Failure(</a>
+<span class="sourceLineNo">1038</span><a id="line.1038">            new IllegalArgumentException(</a>
+<span class="sourceLineNo">1039</span><a id="line.1039">                "get() threw CancellationException, despite reporting isCancelled() == false: "</a>
+<span class="sourceLineNo">1040</span><a id="line.1040">                    + future,</a>
+<span class="sourceLineNo">1041</span><a id="line.1041">                cancellation));</a>
+<span class="sourceLineNo">1042</span><a id="line.1042">      }</a>
+<span class="sourceLineNo">1043</span><a id="line.1043">      return new Cancellation(false, cancellation);</a>
+<span class="sourceLineNo">1044</span><a id="line.1044">    } catch (Exception | Error t) { // sneaky checked exception</a>
+<span class="sourceLineNo">1045</span><a id="line.1045">      return new Failure(t);</a>
+<span class="sourceLineNo">1046</span><a id="line.1046">    }</a>
+<span class="sourceLineNo">1047</span><a id="line.1047">  }</a>
+<span class="sourceLineNo">1048</span><a id="line.1048"></a>
+<span class="sourceLineNo">1049</span><a id="line.1049">  /**</a>
+<span class="sourceLineNo">1050</span><a id="line.1050">   * An inlined private copy of {@link Uninterruptibles#getUninterruptibly} used to break an</a>
+<span class="sourceLineNo">1051</span><a id="line.1051">   * internal dependency on other /util/concurrent classes.</a>
+<span class="sourceLineNo">1052</span><a id="line.1052">   */</a>
+<span class="sourceLineNo">1053</span><a id="line.1053">  @ParametricNullness</a>
+<span class="sourceLineNo">1054</span><a id="line.1054">  private static &lt;V extends @Nullable Object&gt; V getUninterruptibly(Future&lt;V&gt; future)</a>
+<span class="sourceLineNo">1055</span><a id="line.1055">      throws ExecutionException {</a>
+<span class="sourceLineNo">1056</span><a id="line.1056">    boolean interrupted = false;</a>
+<span class="sourceLineNo">1057</span><a id="line.1057">    try {</a>
+<span class="sourceLineNo">1058</span><a id="line.1058">      while (true) {</a>
+<span class="sourceLineNo">1059</span><a id="line.1059">        try {</a>
+<span class="sourceLineNo">1060</span><a id="line.1060">          return future.get();</a>
+<span class="sourceLineNo">1061</span><a id="line.1061">        } catch (InterruptedException e) {</a>
+<span class="sourceLineNo">1062</span><a id="line.1062">          interrupted = true;</a>
+<span class="sourceLineNo">1063</span><a id="line.1063">        }</a>
+<span class="sourceLineNo">1064</span><a id="line.1064">      }</a>
+<span class="sourceLineNo">1065</span><a id="line.1065">    } finally {</a>
+<span class="sourceLineNo">1066</span><a id="line.1066">      if (interrupted) {</a>
+<span class="sourceLineNo">1067</span><a id="line.1067">        Thread.currentThread().interrupt();</a>
+<span class="sourceLineNo">1068</span><a id="line.1068">      }</a>
+<span class="sourceLineNo">1069</span><a id="line.1069">    }</a>
+<span class="sourceLineNo">1070</span><a id="line.1070">  }</a>
+<span class="sourceLineNo">1071</span><a id="line.1071"></a>
+<span class="sourceLineNo">1072</span><a id="line.1072">  /** Unblocks all threads and runs all listeners. */</a>
+<span class="sourceLineNo">1073</span><a id="line.1073">  private static void complete(AbstractFuture&lt;?&gt; param, boolean callInterruptTask) {</a>
+<span class="sourceLineNo">1074</span><a id="line.1074">    // Declare a "true" local variable so that the Checker Framework will infer nullness.</a>
+<span class="sourceLineNo">1075</span><a id="line.1075">    AbstractFuture&lt;?&gt; future = param;</a>
+<span class="sourceLineNo">1076</span><a id="line.1076"></a>
+<span class="sourceLineNo">1077</span><a id="line.1077">    Listener next = null;</a>
+<span class="sourceLineNo">1078</span><a id="line.1078">    outer:</a>
+<span class="sourceLineNo">1079</span><a id="line.1079">    while (true) {</a>
+<span class="sourceLineNo">1080</span><a id="line.1080">      future.releaseWaiters();</a>
+<span class="sourceLineNo">1081</span><a id="line.1081">      /*</a>
+<span class="sourceLineNo">1082</span><a id="line.1082">       * We call interruptTask() immediately before afterDone() so that migrating between the two</a>
+<span class="sourceLineNo">1083</span><a id="line.1083">       * can be a no-op.</a>
+<span class="sourceLineNo">1084</span><a id="line.1084">       */</a>
+<span class="sourceLineNo">1085</span><a id="line.1085">      if (callInterruptTask) {</a>
+<span class="sourceLineNo">1086</span><a id="line.1086">        future.interruptTask();</a>
+<span class="sourceLineNo">1087</span><a id="line.1087">        /*</a>
+<span class="sourceLineNo">1088</span><a id="line.1088">         * Interruption doesn't propagate through a SetFuture chain (see getFutureValue), so don't</a>
+<span class="sourceLineNo">1089</span><a id="line.1089">         * invoke interruptTask on any subsequent futures.</a>
+<span class="sourceLineNo">1090</span><a id="line.1090">         */</a>
+<span class="sourceLineNo">1091</span><a id="line.1091">        callInterruptTask = false;</a>
+<span class="sourceLineNo">1092</span><a id="line.1092">      }</a>
+<span class="sourceLineNo">1093</span><a id="line.1093">      // We call this before the listeners in order to avoid needing to manage a separate stack data</a>
+<span class="sourceLineNo">1094</span><a id="line.1094">      // structure for them.  Also, some implementations rely on this running prior to listeners</a>
+<span class="sourceLineNo">1095</span><a id="line.1095">      // so that the cleanup work is visible to listeners.</a>
+<span class="sourceLineNo">1096</span><a id="line.1096">      // afterDone() should be generally fast and only used for cleanup work... but in theory can</a>
+<span class="sourceLineNo">1097</span><a id="line.1097">      // also be recursive and create StackOverflowErrors</a>
+<span class="sourceLineNo">1098</span><a id="line.1098">      future.afterDone();</a>
+<span class="sourceLineNo">1099</span><a id="line.1099">      // push the current set of listeners onto next</a>
+<span class="sourceLineNo">1100</span><a id="line.1100">      next = future.clearListeners(next);</a>
+<span class="sourceLineNo">1101</span><a id="line.1101">      future = null;</a>
+<span class="sourceLineNo">1102</span><a id="line.1102">      while (next != null) {</a>
+<span class="sourceLineNo">1103</span><a id="line.1103">        Listener curr = next;</a>
+<span class="sourceLineNo">1104</span><a id="line.1104">        next = next.next;</a>
+<span class="sourceLineNo">1105</span><a id="line.1105">        /*</a>
+<span class="sourceLineNo">1106</span><a id="line.1106">         * requireNonNull is safe because the listener stack never contains TOMBSTONE until after</a>
+<span class="sourceLineNo">1107</span><a id="line.1107">         * clearListeners.</a>
+<span class="sourceLineNo">1108</span><a id="line.1108">         */</a>
+<span class="sourceLineNo">1109</span><a id="line.1109">        Runnable task = requireNonNull(curr.task);</a>
+<span class="sourceLineNo">1110</span><a id="line.1110">        if (task instanceof SetFuture) {</a>
+<span class="sourceLineNo">1111</span><a id="line.1111">          SetFuture&lt;?&gt; setFuture = (SetFuture&lt;?&gt;) task;</a>
+<span class="sourceLineNo">1112</span><a id="line.1112">          // We unwind setFuture specifically to avoid StackOverflowErrors in the case of long</a>
+<span class="sourceLineNo">1113</span><a id="line.1113">          // chains of SetFutures</a>
+<span class="sourceLineNo">1114</span><a id="line.1114">          // Handling this special case is important because there is no way to pass an executor to</a>
+<span class="sourceLineNo">1115</span><a id="line.1115">          // setFuture, so a user couldn't break the chain by doing this themselves.  It is also</a>
+<span class="sourceLineNo">1116</span><a id="line.1116">          // potentially common if someone writes a recursive Futures.transformAsync transformer.</a>
+<span class="sourceLineNo">1117</span><a id="line.1117">          future = setFuture.owner;</a>
+<span class="sourceLineNo">1118</span><a id="line.1118">          if (future.value == setFuture) {</a>
+<span class="sourceLineNo">1119</span><a id="line.1119">            Object valueToSet = getFutureValue(setFuture.future);</a>
+<span class="sourceLineNo">1120</span><a id="line.1120">            if (ATOMIC_HELPER.casValue(future, setFuture, valueToSet)) {</a>
+<span class="sourceLineNo">1121</span><a id="line.1121">              continue outer;</a>
+<span class="sourceLineNo">1122</span><a id="line.1122">            }</a>
+<span class="sourceLineNo">1123</span><a id="line.1123">          }</a>
+<span class="sourceLineNo">1124</span><a id="line.1124">          // otherwise the future we were trying to set is already done.</a>
+<span class="sourceLineNo">1125</span><a id="line.1125">        } else {</a>
+<span class="sourceLineNo">1126</span><a id="line.1126">          /*</a>
+<span class="sourceLineNo">1127</span><a id="line.1127">           * requireNonNull is safe because the listener stack never contains TOMBSTONE until after</a>
+<span class="sourceLineNo">1128</span><a id="line.1128">           * clearListeners.</a>
+<span class="sourceLineNo">1129</span><a id="line.1129">           */</a>
+<span class="sourceLineNo">1130</span><a id="line.1130">          executeListener(task, requireNonNull(curr.executor));</a>
+<span class="sourceLineNo">1131</span><a id="line.1131">        }</a>
+<span class="sourceLineNo">1132</span><a id="line.1132">      }</a>
+<span class="sourceLineNo">1133</span><a id="line.1133">      break;</a>
+<span class="sourceLineNo">1134</span><a id="line.1134">    }</a>
+<span class="sourceLineNo">1135</span><a id="line.1135">  }</a>
+<span class="sourceLineNo">1136</span><a id="line.1136"></a>
+<span class="sourceLineNo">1137</span><a id="line.1137">  /**</a>
+<span class="sourceLineNo">1138</span><a id="line.1138">   * Callback method that is called exactly once after the future is completed.</a>
+<span class="sourceLineNo">1139</span><a id="line.1139">   *</a>
+<span class="sourceLineNo">1140</span><a id="line.1140">   * &lt;p&gt;If {@link #interruptTask} is also run during completion, {@link #afterDone} runs after it.</a>
+<span class="sourceLineNo">1141</span><a id="line.1141">   *</a>
+<span class="sourceLineNo">1142</span><a id="line.1142">   * &lt;p&gt;The default implementation of this method in {@code AbstractFuture} does nothing. This is</a>
+<span class="sourceLineNo">1143</span><a id="line.1143">   * intended for very lightweight cleanup work, for example, timing statistics or clearing fields.</a>
+<span class="sourceLineNo">1144</span><a id="line.1144">   * If your task does anything heavier consider, just using a listener with an executor.</a>
+<span class="sourceLineNo">1145</span><a id="line.1145">   *</a>
+<span class="sourceLineNo">1146</span><a id="line.1146">   * @since 20.0</a>
 <span class="sourceLineNo">1147</span><a id="line.1147">   */</a>
-<span class="sourceLineNo">1148</span><a id="line.1148">  private @Nullable Listener clearListeners(@Nullable Listener onto) {</a>
-<span class="sourceLineNo">1149</span><a id="line.1149">    // We need to</a>
-<span class="sourceLineNo">1150</span><a id="line.1150">    // 1. atomically swap the listeners with TOMBSTONE, this is because addListener uses that</a>
-<span class="sourceLineNo">1151</span><a id="line.1151">    //    to synchronize with us</a>
-<span class="sourceLineNo">1152</span><a id="line.1152">    // 2. reverse the linked list, because despite our rather clear contract, people depend on us</a>
-<span class="sourceLineNo">1153</span><a id="line.1153">    //    executing listeners in the order they were added</a>
-<span class="sourceLineNo">1154</span><a id="line.1154">    // 3. push all the items onto 'onto' and return the new head of the stack</a>
-<span class="sourceLineNo">1155</span><a id="line.1155">    Listener head = ATOMIC_HELPER.gasListeners(this, Listener.TOMBSTONE);</a>
-<span class="sourceLineNo">1156</span><a id="line.1156">    Listener reversedList = onto;</a>
-<span class="sourceLineNo">1157</span><a id="line.1157">    while (head != null) {</a>
-<span class="sourceLineNo">1158</span><a id="line.1158">      Listener tmp = head;</a>
-<span class="sourceLineNo">1159</span><a id="line.1159">      head = head.next;</a>
-<span class="sourceLineNo">1160</span><a id="line.1160">      tmp.next = reversedList;</a>
-<span class="sourceLineNo">1161</span><a id="line.1161">      reversedList = tmp;</a>
-<span class="sourceLineNo">1162</span><a id="line.1162">    }</a>
-<span class="sourceLineNo">1163</span><a id="line.1163">    return reversedList;</a>
-<span class="sourceLineNo">1164</span><a id="line.1164">  }</a>
-<span class="sourceLineNo">1165</span><a id="line.1165"></a>
-<span class="sourceLineNo">1166</span><a id="line.1166">  // TODO(user): move parts into a default method on ListenableFuture?</a>
-<span class="sourceLineNo">1167</span><a id="line.1167">  @Override</a>
-<span class="sourceLineNo">1168</span><a id="line.1168">  public String toString() {</a>
-<span class="sourceLineNo">1169</span><a id="line.1169">    // TODO(cpovirk): Presize to something plausible?</a>
-<span class="sourceLineNo">1170</span><a id="line.1170">    StringBuilder builder = new StringBuilder();</a>
-<span class="sourceLineNo">1171</span><a id="line.1171">    if (getClass().getName().startsWith("com.google.common.util.concurrent.")) {</a>
-<span class="sourceLineNo">1172</span><a id="line.1172">      builder.append(getClass().getSimpleName());</a>
-<span class="sourceLineNo">1173</span><a id="line.1173">    } else {</a>
-<span class="sourceLineNo">1174</span><a id="line.1174">      builder.append(getClass().getName());</a>
-<span class="sourceLineNo">1175</span><a id="line.1175">    }</a>
-<span class="sourceLineNo">1176</span><a id="line.1176">    builder.append('@').append(toHexString(identityHashCode(this))).append("[status=");</a>
-<span class="sourceLineNo">1177</span><a id="line.1177">    if (isCancelled()) {</a>
-<span class="sourceLineNo">1178</span><a id="line.1178">      builder.append("CANCELLED");</a>
-<span class="sourceLineNo">1179</span><a id="line.1179">    } else if (isDone()) {</a>
-<span class="sourceLineNo">1180</span><a id="line.1180">      addDoneString(builder);</a>
-<span class="sourceLineNo">1181</span><a id="line.1181">    } else {</a>
-<span class="sourceLineNo">1182</span><a id="line.1182">      addPendingString(builder); // delegates to addDoneString if future completes midway</a>
-<span class="sourceLineNo">1183</span><a id="line.1183">    }</a>
-<span class="sourceLineNo">1184</span><a id="line.1184">    return builder.append("]").toString();</a>
-<span class="sourceLineNo">1185</span><a id="line.1185">  }</a>
-<span class="sourceLineNo">1186</span><a id="line.1186"></a>
-<span class="sourceLineNo">1187</span><a id="line.1187">  /**</a>
-<span class="sourceLineNo">1188</span><a id="line.1188">   * Provide a human-readable explanation of why this future has not yet completed.</a>
-<span class="sourceLineNo">1189</span><a id="line.1189">   *</a>
-<span class="sourceLineNo">1190</span><a id="line.1190">   * @return null if an explanation cannot be provided (e.g. because the future is done).</a>
-<span class="sourceLineNo">1191</span><a id="line.1191">   * @since 23.0</a>
-<span class="sourceLineNo">1192</span><a id="line.1192">   */</a>
-<span class="sourceLineNo">1193</span><a id="line.1193">  protected @Nullable String pendingToString() {</a>
-<span class="sourceLineNo">1194</span><a id="line.1194">    // TODO(diamondm) consider moving this into addPendingString so it's always in the output</a>
-<span class="sourceLineNo">1195</span><a id="line.1195">    if (this instanceof ScheduledFuture) {</a>
-<span class="sourceLineNo">1196</span><a id="line.1196">      return "remaining delay=[" + ((ScheduledFuture) this).getDelay(MILLISECONDS) + " ms]";</a>
-<span class="sourceLineNo">1197</span><a id="line.1197">    }</a>
-<span class="sourceLineNo">1198</span><a id="line.1198">    return null;</a>
-<span class="sourceLineNo">1199</span><a id="line.1199">  }</a>
-<span class="sourceLineNo">1200</span><a id="line.1200"></a>
-<span class="sourceLineNo">1201</span><a id="line.1201">  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception</a>
-<span class="sourceLineNo">1202</span><a id="line.1202">  private void addPendingString(StringBuilder builder) {</a>
-<span class="sourceLineNo">1203</span><a id="line.1203">    // Capture current builder length so it can be truncated if this future ends up completing while</a>
-<span class="sourceLineNo">1204</span><a id="line.1204">    // the toString is being calculated</a>
-<span class="sourceLineNo">1205</span><a id="line.1205">    int truncateLength = builder.length();</a>
-<span class="sourceLineNo">1206</span><a id="line.1206"></a>
-<span class="sourceLineNo">1207</span><a id="line.1207">    builder.append("PENDING");</a>
-<span class="sourceLineNo">1208</span><a id="line.1208"></a>
-<span class="sourceLineNo">1209</span><a id="line.1209">    @RetainedLocalRef Object localValue = value;</a>
-<span class="sourceLineNo">1210</span><a id="line.1210">    if (localValue instanceof SetFuture) {</a>
-<span class="sourceLineNo">1211</span><a id="line.1211">      builder.append(", setFuture=[");</a>
-<span class="sourceLineNo">1212</span><a id="line.1212">      appendUserObject(builder, ((SetFuture) localValue).future);</a>
-<span class="sourceLineNo">1213</span><a id="line.1213">      builder.append("]");</a>
-<span class="sourceLineNo">1214</span><a id="line.1214">    } else {</a>
-<span class="sourceLineNo">1215</span><a id="line.1215">      String pendingDescription;</a>
-<span class="sourceLineNo">1216</span><a id="line.1216">      try {</a>
-<span class="sourceLineNo">1217</span><a id="line.1217">        pendingDescription = Strings.emptyToNull(pendingToString());</a>
-<span class="sourceLineNo">1218</span><a id="line.1218">      } catch (Exception | StackOverflowError e) {</a>
-<span class="sourceLineNo">1219</span><a id="line.1219">        // Any Exception is either a RuntimeException or sneaky checked exception.</a>
-<span class="sourceLineNo">1220</span><a id="line.1220">        //</a>
-<span class="sourceLineNo">1221</span><a id="line.1221">        // Don't call getMessage or toString() on the exception, in case the exception thrown by the</a>
-<span class="sourceLineNo">1222</span><a id="line.1222">        // subclass is implemented with bugs similar to the subclass.</a>
-<span class="sourceLineNo">1223</span><a id="line.1223">        pendingDescription = "Exception thrown from implementation: " + e.getClass();</a>
-<span class="sourceLineNo">1224</span><a id="line.1224">      }</a>
-<span class="sourceLineNo">1225</span><a id="line.1225">      if (pendingDescription != null) {</a>
-<span class="sourceLineNo">1226</span><a id="line.1226">        builder.append(", info=[").append(pendingDescription).append("]");</a>
-<span class="sourceLineNo">1227</span><a id="line.1227">      }</a>
-<span class="sourceLineNo">1228</span><a id="line.1228">    }</a>
-<span class="sourceLineNo">1229</span><a id="line.1229"></a>
-<span class="sourceLineNo">1230</span><a id="line.1230">    // The future may complete while calculating the toString, so we check once more to see if the</a>
-<span class="sourceLineNo">1231</span><a id="line.1231">    // future is done</a>
-<span class="sourceLineNo">1232</span><a id="line.1232">    if (isDone()) {</a>
-<span class="sourceLineNo">1233</span><a id="line.1233">      // Truncate anything that was appended before realizing this future is done</a>
-<span class="sourceLineNo">1234</span><a id="line.1234">      builder.delete(truncateLength, builder.length());</a>
-<span class="sourceLineNo">1235</span><a id="line.1235">      addDoneString(builder);</a>
-<span class="sourceLineNo">1236</span><a id="line.1236">    }</a>
-<span class="sourceLineNo">1237</span><a id="line.1237">  }</a>
-<span class="sourceLineNo">1238</span><a id="line.1238"></a>
-<span class="sourceLineNo">1239</span><a id="line.1239">  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception</a>
-<span class="sourceLineNo">1240</span><a id="line.1240">  private void addDoneString(StringBuilder builder) {</a>
-<span class="sourceLineNo">1241</span><a id="line.1241">    try {</a>
-<span class="sourceLineNo">1242</span><a id="line.1242">      V value = getUninterruptibly(this);</a>
-<span class="sourceLineNo">1243</span><a id="line.1243">      builder.append("SUCCESS, result=[");</a>
-<span class="sourceLineNo">1244</span><a id="line.1244">      appendResultObject(builder, value);</a>
-<span class="sourceLineNo">1245</span><a id="line.1245">      builder.append("]");</a>
-<span class="sourceLineNo">1246</span><a id="line.1246">    } catch (ExecutionException e) {</a>
-<span class="sourceLineNo">1247</span><a id="line.1247">      builder.append("FAILURE, cause=[").append(e.getCause()).append("]");</a>
-<span class="sourceLineNo">1248</span><a id="line.1248">    } catch (CancellationException e) {</a>
-<span class="sourceLineNo">1249</span><a id="line.1249">      builder.append("CANCELLED"); // shouldn't be reachable</a>
-<span class="sourceLineNo">1250</span><a id="line.1250">    } catch (Exception e) { // sneaky checked exception</a>
-<span class="sourceLineNo">1251</span><a id="line.1251">      builder.append("UNKNOWN, cause=[").append(e.getClass()).append(" thrown from get()]");</a>
-<span class="sourceLineNo">1252</span><a id="line.1252">    }</a>
-<span class="sourceLineNo">1253</span><a id="line.1253">  }</a>
-<span class="sourceLineNo">1254</span><a id="line.1254"></a>
-<span class="sourceLineNo">1255</span><a id="line.1255">  /**</a>
-<span class="sourceLineNo">1256</span><a id="line.1256">   * Any object can be the result of a Future, and not every object has a reasonable toString()</a>
-<span class="sourceLineNo">1257</span><a id="line.1257">   * implementation. Using a reconstruction of the default Object.toString() prevents OOMs and stack</a>
-<span class="sourceLineNo">1258</span><a id="line.1258">   * overflows, and helps avoid sensitive data inadvertently ending up in exception messages.</a>
-<span class="sourceLineNo">1259</span><a id="line.1259">   */</a>
-<span class="sourceLineNo">1260</span><a id="line.1260">  private void appendResultObject(StringBuilder builder, @Nullable Object o) {</a>
-<span class="sourceLineNo">1261</span><a id="line.1261">    if (o == null) {</a>
-<span class="sourceLineNo">1262</span><a id="line.1262">      builder.append("null");</a>
-<span class="sourceLineNo">1263</span><a id="line.1263">    } else if (o == this) {</a>
-<span class="sourceLineNo">1264</span><a id="line.1264">      builder.append("this future");</a>
-<span class="sourceLineNo">1265</span><a id="line.1265">    } else {</a>
-<span class="sourceLineNo">1266</span><a id="line.1266">      builder</a>
-<span class="sourceLineNo">1267</span><a id="line.1267">          .append(o.getClass().getName())</a>
-<span class="sourceLineNo">1268</span><a id="line.1268">          .append("@")</a>
-<span class="sourceLineNo">1269</span><a id="line.1269">          .append(Integer.toHexString(System.identityHashCode(o)));</a>
-<span class="sourceLineNo">1270</span><a id="line.1270">    }</a>
-<span class="sourceLineNo">1271</span><a id="line.1271">  }</a>
-<span class="sourceLineNo">1272</span><a id="line.1272"></a>
-<span class="sourceLineNo">1273</span><a id="line.1273">  /** Helper for printing user supplied objects into our toString method. */</a>
-<span class="sourceLineNo">1274</span><a id="line.1274">  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception</a>
-<span class="sourceLineNo">1275</span><a id="line.1275">  private void appendUserObject(StringBuilder builder, @Nullable Object o) {</a>
-<span class="sourceLineNo">1276</span><a id="line.1276">    // This is some basic recursion detection for when people create cycles via set/setFuture or</a>
-<span class="sourceLineNo">1277</span><a id="line.1277">    // when deep chains of futures exist resulting in a StackOverflowException. We could detect</a>
-<span class="sourceLineNo">1278</span><a id="line.1278">    // arbitrary cycles using a thread local but this should be a good enough solution (it is also</a>
-<span class="sourceLineNo">1279</span><a id="line.1279">    // what jdk collections do in these cases)</a>
-<span class="sourceLineNo">1280</span><a id="line.1280">    try {</a>
-<span class="sourceLineNo">1281</span><a id="line.1281">      if (o == this) {</a>
-<span class="sourceLineNo">1282</span><a id="line.1282">        builder.append("this future");</a>
-<span class="sourceLineNo">1283</span><a id="line.1283">      } else {</a>
-<span class="sourceLineNo">1284</span><a id="line.1284">        builder.append(o);</a>
-<span class="sourceLineNo">1285</span><a id="line.1285">      }</a>
-<span class="sourceLineNo">1286</span><a id="line.1286">    } catch (Exception | StackOverflowError e) {</a>
-<span class="sourceLineNo">1287</span><a id="line.1287">      // Any Exception is either a RuntimeException or sneaky checked exception.</a>
-<span class="sourceLineNo">1288</span><a id="line.1288">      //</a>
-<span class="sourceLineNo">1289</span><a id="line.1289">      // Don't call getMessage or toString() on the exception, in case the exception thrown by the</a>
-<span class="sourceLineNo">1290</span><a id="line.1290">      // user object is implemented with bugs similar to the user object.</a>
-<span class="sourceLineNo">1291</span><a id="line.1291">      builder.append("Exception thrown from implementation: ").append(e.getClass());</a>
-<span class="sourceLineNo">1292</span><a id="line.1292">    }</a>
-<span class="sourceLineNo">1293</span><a id="line.1293">  }</a>
-<span class="sourceLineNo">1294</span><a id="line.1294"></a>
-<span class="sourceLineNo">1295</span><a id="line.1295">  /**</a>
-<span class="sourceLineNo">1296</span><a id="line.1296">   * Submits the given runnable to the given {@link Executor} catching and logging all {@linkplain</a>
-<span class="sourceLineNo">1297</span><a id="line.1297">   * RuntimeException runtime exceptions} thrown by the executor.</a>
-<span class="sourceLineNo">1298</span><a id="line.1298">   */</a>
-<span class="sourceLineNo">1299</span><a id="line.1299">  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception</a>
-<span class="sourceLineNo">1300</span><a id="line.1300">  private static void executeListener(Runnable runnable, Executor executor) {</a>
-<span class="sourceLineNo">1301</span><a id="line.1301">    try {</a>
-<span class="sourceLineNo">1302</span><a id="line.1302">      executor.execute(runnable);</a>
-<span class="sourceLineNo">1303</span><a id="line.1303">    } catch (Exception e) { // sneaky checked exception</a>
-<span class="sourceLineNo">1304</span><a id="line.1304">      // Log it and keep going -- bad runnable and/or executor. Don't punish the other runnables if</a>
-<span class="sourceLineNo">1305</span><a id="line.1305">      // we're given a bad one. We only catch Exception because we want Errors to propagate up.</a>
-<span class="sourceLineNo">1306</span><a id="line.1306">      log.get()</a>
-<span class="sourceLineNo">1307</span><a id="line.1307">          .log(</a>
-<span class="sourceLineNo">1308</span><a id="line.1308">              Level.SEVERE,</a>
-<span class="sourceLineNo">1309</span><a id="line.1309">              "RuntimeException while executing runnable "</a>
-<span class="sourceLineNo">1310</span><a id="line.1310">                  + runnable</a>
-<span class="sourceLineNo">1311</span><a id="line.1311">                  + " with executor "</a>
-<span class="sourceLineNo">1312</span><a id="line.1312">                  + executor,</a>
-<span class="sourceLineNo">1313</span><a id="line.1313">              e);</a>
+<span class="sourceLineNo">1148</span><a id="line.1148">  @ForOverride</a>
+<span class="sourceLineNo">1149</span><a id="line.1149">  protected void afterDone() {}</a>
+<span class="sourceLineNo">1150</span><a id="line.1150"></a>
+<span class="sourceLineNo">1151</span><a id="line.1151">  // TODO(b/114236866): Inherit doc from InternalFutureFailureAccess. Also, -link to its URL.</a>
+<span class="sourceLineNo">1152</span><a id="line.1152">  /**</a>
+<span class="sourceLineNo">1153</span><a id="line.1153">   * Usually returns {@code null} but, if this {@code Future} has failed, may &lt;i&gt;optionally&lt;/i&gt;</a>
+<span class="sourceLineNo">1154</span><a id="line.1154">   * return the cause of the failure. "Failure" means specifically "completed with an exception"; it</a>
+<span class="sourceLineNo">1155</span><a id="line.1155">   * does not include "was cancelled." To be explicit: If this method returns a non-null value,</a>
+<span class="sourceLineNo">1156</span><a id="line.1156">   * then:</a>
+<span class="sourceLineNo">1157</span><a id="line.1157">   *</a>
+<span class="sourceLineNo">1158</span><a id="line.1158">   * &lt;ul&gt;</a>
+<span class="sourceLineNo">1159</span><a id="line.1159">   *   &lt;li&gt;{@code isDone()} must return {@code true}</a>
+<span class="sourceLineNo">1160</span><a id="line.1160">   *   &lt;li&gt;{@code isCancelled()} must return {@code false}</a>
+<span class="sourceLineNo">1161</span><a id="line.1161">   *   &lt;li&gt;{@code get()} must not block, and it must throw an {@code ExecutionException} with the</a>
+<span class="sourceLineNo">1162</span><a id="line.1162">   *       return value of this method as its cause</a>
+<span class="sourceLineNo">1163</span><a id="line.1163">   * &lt;/ul&gt;</a>
+<span class="sourceLineNo">1164</span><a id="line.1164">   *</a>
+<span class="sourceLineNo">1165</span><a id="line.1165">   * &lt;p&gt;This method is {@code protected} so that classes like {@code</a>
+<span class="sourceLineNo">1166</span><a id="line.1166">   * com.google.common.util.concurrent.SettableFuture} do not expose it to their users as an</a>
+<span class="sourceLineNo">1167</span><a id="line.1167">   * instance method. In the unlikely event that you need to call this method, call {@link</a>
+<span class="sourceLineNo">1168</span><a id="line.1168">   * InternalFutures#tryInternalFastPathGetFailure(InternalFutureFailureAccess)}.</a>
+<span class="sourceLineNo">1169</span><a id="line.1169">   *</a>
+<span class="sourceLineNo">1170</span><a id="line.1170">   * @since 27.0</a>
+<span class="sourceLineNo">1171</span><a id="line.1171">   */</a>
+<span class="sourceLineNo">1172</span><a id="line.1172">  @Override</a>
+<span class="sourceLineNo">1173</span><a id="line.1173">  /*</a>
+<span class="sourceLineNo">1174</span><a id="line.1174">   * We should annotate the superclass, InternalFutureFailureAccess, to say that its copy of this</a>
+<span class="sourceLineNo">1175</span><a id="line.1175">   * method returns @Nullable, too. However, we're not sure if we want to make any changes to that</a>
+<span class="sourceLineNo">1176</span><a id="line.1176">   * class, since it's in a separate artifact that we planned to release only a single version of.</a>
+<span class="sourceLineNo">1177</span><a id="line.1177">   */</a>
+<span class="sourceLineNo">1178</span><a id="line.1178">  protected final @Nullable Throwable tryInternalFastPathGetFailure() {</a>
+<span class="sourceLineNo">1179</span><a id="line.1179">    if (this instanceof Trusted) {</a>
+<span class="sourceLineNo">1180</span><a id="line.1180">      @RetainedLocalRef Object localValue = value;</a>
+<span class="sourceLineNo">1181</span><a id="line.1181">      if (localValue instanceof Failure) {</a>
+<span class="sourceLineNo">1182</span><a id="line.1182">        return ((Failure) localValue).exception;</a>
+<span class="sourceLineNo">1183</span><a id="line.1183">      }</a>
+<span class="sourceLineNo">1184</span><a id="line.1184">    }</a>
+<span class="sourceLineNo">1185</span><a id="line.1185">    return null;</a>
+<span class="sourceLineNo">1186</span><a id="line.1186">  }</a>
+<span class="sourceLineNo">1187</span><a id="line.1187"></a>
+<span class="sourceLineNo">1188</span><a id="line.1188">  /**</a>
+<span class="sourceLineNo">1189</span><a id="line.1189">   * If this future has been cancelled (and possibly interrupted), cancels (and possibly interrupts)</a>
+<span class="sourceLineNo">1190</span><a id="line.1190">   * the given future (if available).</a>
+<span class="sourceLineNo">1191</span><a id="line.1191">   */</a>
+<span class="sourceLineNo">1192</span><a id="line.1192">  final void maybePropagateCancellationTo(@Nullable Future&lt;?&gt; related) {</a>
+<span class="sourceLineNo">1193</span><a id="line.1193">    if (related != null &amp; isCancelled()) {</a>
+<span class="sourceLineNo">1194</span><a id="line.1194">      related.cancel(wasInterrupted());</a>
+<span class="sourceLineNo">1195</span><a id="line.1195">    }</a>
+<span class="sourceLineNo">1196</span><a id="line.1196">  }</a>
+<span class="sourceLineNo">1197</span><a id="line.1197"></a>
+<span class="sourceLineNo">1198</span><a id="line.1198">  /** Releases all threads in the {@link #waiters} list, and clears the list. */</a>
+<span class="sourceLineNo">1199</span><a id="line.1199">  private void releaseWaiters() {</a>
+<span class="sourceLineNo">1200</span><a id="line.1200">    Waiter head = ATOMIC_HELPER.gasWaiters(this, Waiter.TOMBSTONE);</a>
+<span class="sourceLineNo">1201</span><a id="line.1201">    for (Waiter currentWaiter = head; currentWaiter != null; currentWaiter = currentWaiter.next) {</a>
+<span class="sourceLineNo">1202</span><a id="line.1202">      currentWaiter.unpark();</a>
+<span class="sourceLineNo">1203</span><a id="line.1203">    }</a>
+<span class="sourceLineNo">1204</span><a id="line.1204">  }</a>
+<span class="sourceLineNo">1205</span><a id="line.1205"></a>
+<span class="sourceLineNo">1206</span><a id="line.1206">  /**</a>
+<span class="sourceLineNo">1207</span><a id="line.1207">   * Clears the {@link #listeners} list and prepends its contents to {@code onto}, least recently</a>
+<span class="sourceLineNo">1208</span><a id="line.1208">   * added first.</a>
+<span class="sourceLineNo">1209</span><a id="line.1209">   */</a>
+<span class="sourceLineNo">1210</span><a id="line.1210">  private @Nullable Listener clearListeners(@Nullable Listener onto) {</a>
+<span class="sourceLineNo">1211</span><a id="line.1211">    // We need to</a>
+<span class="sourceLineNo">1212</span><a id="line.1212">    // 1. atomically swap the listeners with TOMBSTONE, this is because addListener uses that</a>
+<span class="sourceLineNo">1213</span><a id="line.1213">    //    to synchronize with us</a>
+<span class="sourceLineNo">1214</span><a id="line.1214">    // 2. reverse the linked list, because despite our rather clear contract, people depend on us</a>
+<span class="sourceLineNo">1215</span><a id="line.1215">    //    executing listeners in the order they were added</a>
+<span class="sourceLineNo">1216</span><a id="line.1216">    // 3. push all the items onto 'onto' and return the new head of the stack</a>
+<span class="sourceLineNo">1217</span><a id="line.1217">    Listener head = ATOMIC_HELPER.gasListeners(this, Listener.TOMBSTONE);</a>
+<span class="sourceLineNo">1218</span><a id="line.1218">    Listener reversedList = onto;</a>
+<span class="sourceLineNo">1219</span><a id="line.1219">    while (head != null) {</a>
+<span class="sourceLineNo">1220</span><a id="line.1220">      Listener tmp = head;</a>
+<span class="sourceLineNo">1221</span><a id="line.1221">      head = head.next;</a>
+<span class="sourceLineNo">1222</span><a id="line.1222">      tmp.next = reversedList;</a>
+<span class="sourceLineNo">1223</span><a id="line.1223">      reversedList = tmp;</a>
+<span class="sourceLineNo">1224</span><a id="line.1224">    }</a>
+<span class="sourceLineNo">1225</span><a id="line.1225">    return reversedList;</a>
+<span class="sourceLineNo">1226</span><a id="line.1226">  }</a>
+<span class="sourceLineNo">1227</span><a id="line.1227"></a>
+<span class="sourceLineNo">1228</span><a id="line.1228">  // TODO(user): move parts into a default method on ListenableFuture?</a>
+<span class="sourceLineNo">1229</span><a id="line.1229">  @Override</a>
+<span class="sourceLineNo">1230</span><a id="line.1230">  public String toString() {</a>
+<span class="sourceLineNo">1231</span><a id="line.1231">    // TODO(cpovirk): Presize to something plausible?</a>
+<span class="sourceLineNo">1232</span><a id="line.1232">    StringBuilder builder = new StringBuilder();</a>
+<span class="sourceLineNo">1233</span><a id="line.1233">    if (getClass().getName().startsWith("com.google.common.util.concurrent.")) {</a>
+<span class="sourceLineNo">1234</span><a id="line.1234">      builder.append(getClass().getSimpleName());</a>
+<span class="sourceLineNo">1235</span><a id="line.1235">    } else {</a>
+<span class="sourceLineNo">1236</span><a id="line.1236">      builder.append(getClass().getName());</a>
+<span class="sourceLineNo">1237</span><a id="line.1237">    }</a>
+<span class="sourceLineNo">1238</span><a id="line.1238">    builder.append('@').append(toHexString(identityHashCode(this))).append("[status=");</a>
+<span class="sourceLineNo">1239</span><a id="line.1239">    if (isCancelled()) {</a>
+<span class="sourceLineNo">1240</span><a id="line.1240">      builder.append("CANCELLED");</a>
+<span class="sourceLineNo">1241</span><a id="line.1241">    } else if (isDone()) {</a>
+<span class="sourceLineNo">1242</span><a id="line.1242">      addDoneString(builder);</a>
+<span class="sourceLineNo">1243</span><a id="line.1243">    } else {</a>
+<span class="sourceLineNo">1244</span><a id="line.1244">      addPendingString(builder); // delegates to addDoneString if future completes midway</a>
+<span class="sourceLineNo">1245</span><a id="line.1245">    }</a>
+<span class="sourceLineNo">1246</span><a id="line.1246">    return builder.append("]").toString();</a>
+<span class="sourceLineNo">1247</span><a id="line.1247">  }</a>
+<span class="sourceLineNo">1248</span><a id="line.1248"></a>
+<span class="sourceLineNo">1249</span><a id="line.1249">  /**</a>
+<span class="sourceLineNo">1250</span><a id="line.1250">   * Provide a human-readable explanation of why this future has not yet completed.</a>
+<span class="sourceLineNo">1251</span><a id="line.1251">   *</a>
+<span class="sourceLineNo">1252</span><a id="line.1252">   * @return null if an explanation cannot be provided (e.g. because the future is done).</a>
+<span class="sourceLineNo">1253</span><a id="line.1253">   * @since 23.0</a>
+<span class="sourceLineNo">1254</span><a id="line.1254">   */</a>
+<span class="sourceLineNo">1255</span><a id="line.1255">  protected @Nullable String pendingToString() {</a>
+<span class="sourceLineNo">1256</span><a id="line.1256">    // TODO(diamondm) consider moving this into addPendingString so it's always in the output</a>
+<span class="sourceLineNo">1257</span><a id="line.1257">    if (this instanceof ScheduledFuture) {</a>
+<span class="sourceLineNo">1258</span><a id="line.1258">      return "remaining delay=[" + ((ScheduledFuture) this).getDelay(MILLISECONDS) + " ms]";</a>
+<span class="sourceLineNo">1259</span><a id="line.1259">    }</a>
+<span class="sourceLineNo">1260</span><a id="line.1260">    return null;</a>
+<span class="sourceLineNo">1261</span><a id="line.1261">  }</a>
+<span class="sourceLineNo">1262</span><a id="line.1262"></a>
+<span class="sourceLineNo">1263</span><a id="line.1263">  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception</a>
+<span class="sourceLineNo">1264</span><a id="line.1264">  private void addPendingString(StringBuilder builder) {</a>
+<span class="sourceLineNo">1265</span><a id="line.1265">    // Capture current builder length so it can be truncated if this future ends up completing while</a>
+<span class="sourceLineNo">1266</span><a id="line.1266">    // the toString is being calculated</a>
+<span class="sourceLineNo">1267</span><a id="line.1267">    int truncateLength = builder.length();</a>
+<span class="sourceLineNo">1268</span><a id="line.1268"></a>
+<span class="sourceLineNo">1269</span><a id="line.1269">    builder.append("PENDING");</a>
+<span class="sourceLineNo">1270</span><a id="line.1270"></a>
+<span class="sourceLineNo">1271</span><a id="line.1271">    @RetainedLocalRef Object localValue = value;</a>
+<span class="sourceLineNo">1272</span><a id="line.1272">    if (localValue instanceof SetFuture) {</a>
+<span class="sourceLineNo">1273</span><a id="line.1273">      builder.append(", setFuture=[");</a>
+<span class="sourceLineNo">1274</span><a id="line.1274">      appendUserObject(builder, ((SetFuture) localValue).future);</a>
+<span class="sourceLineNo">1275</span><a id="line.1275">      builder.append("]");</a>
+<span class="sourceLineNo">1276</span><a id="line.1276">    } else {</a>
+<span class="sourceLineNo">1277</span><a id="line.1277">      String pendingDescription;</a>
+<span class="sourceLineNo">1278</span><a id="line.1278">      try {</a>
+<span class="sourceLineNo">1279</span><a id="line.1279">        pendingDescription = Strings.emptyToNull(pendingToString());</a>
+<span class="sourceLineNo">1280</span><a id="line.1280">      } catch (Exception | StackOverflowError e) {</a>
+<span class="sourceLineNo">1281</span><a id="line.1281">        // Any Exception is either a RuntimeException or sneaky checked exception.</a>
+<span class="sourceLineNo">1282</span><a id="line.1282">        //</a>
+<span class="sourceLineNo">1283</span><a id="line.1283">        // Don't call getMessage or toString() on the exception, in case the exception thrown by the</a>
+<span class="sourceLineNo">1284</span><a id="line.1284">        // subclass is implemented with bugs similar to the subclass.</a>
+<span class="sourceLineNo">1285</span><a id="line.1285">        pendingDescription = "Exception thrown from implementation: " + e.getClass();</a>
+<span class="sourceLineNo">1286</span><a id="line.1286">      }</a>
+<span class="sourceLineNo">1287</span><a id="line.1287">      if (pendingDescription != null) {</a>
+<span class="sourceLineNo">1288</span><a id="line.1288">        builder.append(", info=[").append(pendingDescription).append("]");</a>
+<span class="sourceLineNo">1289</span><a id="line.1289">      }</a>
+<span class="sourceLineNo">1290</span><a id="line.1290">    }</a>
+<span class="sourceLineNo">1291</span><a id="line.1291"></a>
+<span class="sourceLineNo">1292</span><a id="line.1292">    // The future may complete while calculating the toString, so we check once more to see if the</a>
+<span class="sourceLineNo">1293</span><a id="line.1293">    // future is done</a>
+<span class="sourceLineNo">1294</span><a id="line.1294">    if (isDone()) {</a>
+<span class="sourceLineNo">1295</span><a id="line.1295">      // Truncate anything that was appended before realizing this future is done</a>
+<span class="sourceLineNo">1296</span><a id="line.1296">      builder.delete(truncateLength, builder.length());</a>
+<span class="sourceLineNo">1297</span><a id="line.1297">      addDoneString(builder);</a>
+<span class="sourceLineNo">1298</span><a id="line.1298">    }</a>
+<span class="sourceLineNo">1299</span><a id="line.1299">  }</a>
+<span class="sourceLineNo">1300</span><a id="line.1300"></a>
+<span class="sourceLineNo">1301</span><a id="line.1301">  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception</a>
+<span class="sourceLineNo">1302</span><a id="line.1302">  private void addDoneString(StringBuilder builder) {</a>
+<span class="sourceLineNo">1303</span><a id="line.1303">    try {</a>
+<span class="sourceLineNo">1304</span><a id="line.1304">      V value = getUninterruptibly(this);</a>
+<span class="sourceLineNo">1305</span><a id="line.1305">      builder.append("SUCCESS, result=[");</a>
+<span class="sourceLineNo">1306</span><a id="line.1306">      appendResultObject(builder, value);</a>
+<span class="sourceLineNo">1307</span><a id="line.1307">      builder.append("]");</a>
+<span class="sourceLineNo">1308</span><a id="line.1308">    } catch (ExecutionException e) {</a>
+<span class="sourceLineNo">1309</span><a id="line.1309">      builder.append("FAILURE, cause=[").append(e.getCause()).append("]");</a>
+<span class="sourceLineNo">1310</span><a id="line.1310">    } catch (CancellationException e) {</a>
+<span class="sourceLineNo">1311</span><a id="line.1311">      builder.append("CANCELLED"); // shouldn't be reachable</a>
+<span class="sourceLineNo">1312</span><a id="line.1312">    } catch (Exception e) { // sneaky checked exception</a>
+<span class="sourceLineNo">1313</span><a id="line.1313">      builder.append("UNKNOWN, cause=[").append(e.getClass()).append(" thrown from get()]");</a>
 <span class="sourceLineNo">1314</span><a id="line.1314">    }</a>
 <span class="sourceLineNo">1315</span><a id="line.1315">  }</a>
 <span class="sourceLineNo">1316</span><a id="line.1316"></a>
-<span class="sourceLineNo">1317</span><a id="line.1317">  private abstract static class AtomicHelper {</a>
-<span class="sourceLineNo">1318</span><a id="line.1318">    /** Non-volatile write of the thread to the {@link Waiter#thread} field. */</a>
-<span class="sourceLineNo">1319</span><a id="line.1319">    abstract void putThread(Waiter waiter, Thread newValue);</a>
-<span class="sourceLineNo">1320</span><a id="line.1320"></a>
-<span class="sourceLineNo">1321</span><a id="line.1321">    /** Non-volatile write of the waiter to the {@link Waiter#next} field. */</a>
-<span class="sourceLineNo">1322</span><a id="line.1322">    abstract void putNext(Waiter waiter, @Nullable Waiter newValue);</a>
-<span class="sourceLineNo">1323</span><a id="line.1323"></a>
-<span class="sourceLineNo">1324</span><a id="line.1324">    /** Performs a CAS operation on the {@link AbstractFuture#waiters} field. */</a>
-<span class="sourceLineNo">1325</span><a id="line.1325">    abstract boolean casWaiters(</a>
-<span class="sourceLineNo">1326</span><a id="line.1326">        AbstractFuture&lt;?&gt; future, @Nullable Waiter expect, @Nullable Waiter update);</a>
-<span class="sourceLineNo">1327</span><a id="line.1327"></a>
-<span class="sourceLineNo">1328</span><a id="line.1328">    /** Performs a CAS operation on the {@link AbstractFuture#listeners} field. */</a>
-<span class="sourceLineNo">1329</span><a id="line.1329">    abstract boolean casListeners(</a>
-<span class="sourceLineNo">1330</span><a id="line.1330">        AbstractFuture&lt;?&gt; future, @Nullable Listener expect, Listener update);</a>
-<span class="sourceLineNo">1331</span><a id="line.1331"></a>
-<span class="sourceLineNo">1332</span><a id="line.1332">    /** Performs a GAS operation on the {@link AbstractFuture#waiters} field. */</a>
-<span class="sourceLineNo">1333</span><a id="line.1333">    abstract Waiter gasWaiters(AbstractFuture&lt;?&gt; future, Waiter update);</a>
+<span class="sourceLineNo">1317</span><a id="line.1317">  /**</a>
+<span class="sourceLineNo">1318</span><a id="line.1318">   * Any object can be the result of a Future, and not every object has a reasonable toString()</a>
+<span class="sourceLineNo">1319</span><a id="line.1319">   * implementation. Using a reconstruction of the default Object.toString() prevents OOMs and stack</a>
+<span class="sourceLineNo">1320</span><a id="line.1320">   * overflows, and helps avoid sensitive data inadvertently ending up in exception messages.</a>
+<span class="sourceLineNo">1321</span><a id="line.1321">   */</a>
+<span class="sourceLineNo">1322</span><a id="line.1322">  private void appendResultObject(StringBuilder builder, @Nullable Object o) {</a>
+<span class="sourceLineNo">1323</span><a id="line.1323">    if (o == null) {</a>
+<span class="sourceLineNo">1324</span><a id="line.1324">      builder.append("null");</a>
+<span class="sourceLineNo">1325</span><a id="line.1325">    } else if (o == this) {</a>
+<span class="sourceLineNo">1326</span><a id="line.1326">      builder.append("this future");</a>
+<span class="sourceLineNo">1327</span><a id="line.1327">    } else {</a>
+<span class="sourceLineNo">1328</span><a id="line.1328">      builder</a>
+<span class="sourceLineNo">1329</span><a id="line.1329">          .append(o.getClass().getName())</a>
+<span class="sourceLineNo">1330</span><a id="line.1330">          .append("@")</a>
+<span class="sourceLineNo">1331</span><a id="line.1331">          .append(Integer.toHexString(System.identityHashCode(o)));</a>
+<span class="sourceLineNo">1332</span><a id="line.1332">    }</a>
+<span class="sourceLineNo">1333</span><a id="line.1333">  }</a>
 <span class="sourceLineNo">1334</span><a id="line.1334"></a>
-<span class="sourceLineNo">1335</span><a id="line.1335">    /** Performs a GAS operation on the {@link AbstractFuture#listeners} field. */</a>
-<span class="sourceLineNo">1336</span><a id="line.1336">    abstract Listener gasListeners(AbstractFuture&lt;?&gt; future, Listener update);</a>
-<span class="sourceLineNo">1337</span><a id="line.1337"></a>
-<span class="sourceLineNo">1338</span><a id="line.1338">    /** Performs a CAS operation on the {@link AbstractFuture#value} field. */</a>
-<span class="sourceLineNo">1339</span><a id="line.1339">    abstract boolean casValue(AbstractFuture&lt;?&gt; future, @Nullable Object expect, Object update);</a>
-<span class="sourceLineNo">1340</span><a id="line.1340">  }</a>
-<span class="sourceLineNo">1341</span><a id="line.1341"></a>
-<span class="sourceLineNo">1342</span><a id="line.1342">  /**</a>
-<span class="sourceLineNo">1343</span><a id="line.1343">   * {@link AtomicHelper} based on {@link sun.misc.Unsafe}.</a>
-<span class="sourceLineNo">1344</span><a id="line.1344">   *</a>
-<span class="sourceLineNo">1345</span><a id="line.1345">   * &lt;p&gt;Static initialization of this class will fail if the {@link sun.misc.Unsafe} object cannot</a>
-<span class="sourceLineNo">1346</span><a id="line.1346">   * be accessed.</a>
-<span class="sourceLineNo">1347</span><a id="line.1347">   */</a>
-<span class="sourceLineNo">1348</span><a id="line.1348">  @SuppressWarnings({"SunApi", "removal"}) // b/345822163</a>
-<span class="sourceLineNo">1349</span><a id="line.1349">  private static final class UnsafeAtomicHelper extends AtomicHelper {</a>
-<span class="sourceLineNo">1350</span><a id="line.1350">    static final Unsafe UNSAFE;</a>
-<span class="sourceLineNo">1351</span><a id="line.1351">    static final long LISTENERS_OFFSET;</a>
-<span class="sourceLineNo">1352</span><a id="line.1352">    static final long WAITERS_OFFSET;</a>
-<span class="sourceLineNo">1353</span><a id="line.1353">    static final long VALUE_OFFSET;</a>
-<span class="sourceLineNo">1354</span><a id="line.1354">    static final long WAITER_THREAD_OFFSET;</a>
-<span class="sourceLineNo">1355</span><a id="line.1355">    static final long WAITER_NEXT_OFFSET;</a>
+<span class="sourceLineNo">1335</span><a id="line.1335">  /** Helper for printing user supplied objects into our toString method. */</a>
+<span class="sourceLineNo">1336</span><a id="line.1336">  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception</a>
+<span class="sourceLineNo">1337</span><a id="line.1337">  private void appendUserObject(StringBuilder builder, @Nullable Object o) {</a>
+<span class="sourceLineNo">1338</span><a id="line.1338">    // This is some basic recursion detection for when people create cycles via set/setFuture or</a>
+<span class="sourceLineNo">1339</span><a id="line.1339">    // when deep chains of futures exist resulting in a StackOverflowException. We could detect</a>
+<span class="sourceLineNo">1340</span><a id="line.1340">    // arbitrary cycles using a thread local but this should be a good enough solution (it is also</a>
+<span class="sourceLineNo">1341</span><a id="line.1341">    // what jdk collections do in these cases)</a>
+<span class="sourceLineNo">1342</span><a id="line.1342">    try {</a>
+<span class="sourceLineNo">1343</span><a id="line.1343">      if (o == this) {</a>
+<span class="sourceLineNo">1344</span><a id="line.1344">        builder.append("this future");</a>
+<span class="sourceLineNo">1345</span><a id="line.1345">      } else {</a>
+<span class="sourceLineNo">1346</span><a id="line.1346">        builder.append(o);</a>
+<span class="sourceLineNo">1347</span><a id="line.1347">      }</a>
+<span class="sourceLineNo">1348</span><a id="line.1348">    } catch (Exception | StackOverflowError e) {</a>
+<span class="sourceLineNo">1349</span><a id="line.1349">      // Any Exception is either a RuntimeException or sneaky checked exception.</a>
+<span class="sourceLineNo">1350</span><a id="line.1350">      //</a>
+<span class="sourceLineNo">1351</span><a id="line.1351">      // Don't call getMessage or toString() on the exception, in case the exception thrown by the</a>
+<span class="sourceLineNo">1352</span><a id="line.1352">      // user object is implemented with bugs similar to the user object.</a>
+<span class="sourceLineNo">1353</span><a id="line.1353">      builder.append("Exception thrown from implementation: ").append(e.getClass());</a>
+<span class="sourceLineNo">1354</span><a id="line.1354">    }</a>
+<span class="sourceLineNo">1355</span><a id="line.1355">  }</a>
 <span class="sourceLineNo">1356</span><a id="line.1356"></a>
-<span class="sourceLineNo">1357</span><a id="line.1357">    static {</a>
-<span class="sourceLineNo">1358</span><a id="line.1358">      Unsafe unsafe = null;</a>
-<span class="sourceLineNo">1359</span><a id="line.1359">      try {</a>
-<span class="sourceLineNo">1360</span><a id="line.1360">        unsafe = Unsafe.getUnsafe();</a>
-<span class="sourceLineNo">1361</span><a id="line.1361">      } catch (SecurityException tryReflectionInstead) {</a>
-<span class="sourceLineNo">1362</span><a id="line.1362">        try {</a>
-<span class="sourceLineNo">1363</span><a id="line.1363">          unsafe =</a>
-<span class="sourceLineNo">1364</span><a id="line.1364">              AccessController.doPrivileged(</a>
-<span class="sourceLineNo">1365</span><a id="line.1365">                  new PrivilegedExceptionAction&lt;Unsafe&gt;() {</a>
-<span class="sourceLineNo">1366</span><a id="line.1366">                    @Override</a>
-<span class="sourceLineNo">1367</span><a id="line.1367">                    public Unsafe run() throws Exception {</a>
-<span class="sourceLineNo">1368</span><a id="line.1368">                      Class&lt;Unsafe&gt; k = Unsafe.class;</a>
-<span class="sourceLineNo">1369</span><a id="line.1369">                      for (Field f : k.getDeclaredFields()) {</a>
-<span class="sourceLineNo">1370</span><a id="line.1370">                        f.setAccessible(true);</a>
-<span class="sourceLineNo">1371</span><a id="line.1371">                        Object x = f.get(null);</a>
-<span class="sourceLineNo">1372</span><a id="line.1372">                        if (k.isInstance(x)) {</a>
-<span class="sourceLineNo">1373</span><a id="line.1373">                          return k.cast(x);</a>
-<span class="sourceLineNo">1374</span><a id="line.1374">                        }</a>
-<span class="sourceLineNo">1375</span><a id="line.1375">                      }</a>
-<span class="sourceLineNo">1376</span><a id="line.1376">                      throw new NoSuchFieldError("the Unsafe");</a>
-<span class="sourceLineNo">1377</span><a id="line.1377">                    }</a>
-<span class="sourceLineNo">1378</span><a id="line.1378">                  });</a>
-<span class="sourceLineNo">1379</span><a id="line.1379">        } catch (PrivilegedActionException e) {</a>
-<span class="sourceLineNo">1380</span><a id="line.1380">          throw new RuntimeException("Could not initialize intrinsics", e.getCause());</a>
-<span class="sourceLineNo">1381</span><a id="line.1381">        }</a>
-<span class="sourceLineNo">1382</span><a id="line.1382">      }</a>
-<span class="sourceLineNo">1383</span><a id="line.1383">      try {</a>
-<span class="sourceLineNo">1384</span><a id="line.1384">        Class&lt;?&gt; abstractFuture = AbstractFuture.class;</a>
-<span class="sourceLineNo">1385</span><a id="line.1385">        WAITERS_OFFSET = unsafe.objectFieldOffset(abstractFuture.getDeclaredField("waiters"));</a>
-<span class="sourceLineNo">1386</span><a id="line.1386">        LISTENERS_OFFSET = unsafe.objectFieldOffset(abstractFuture.getDeclaredField("listeners"));</a>
-<span class="sourceLineNo">1387</span><a id="line.1387">        VALUE_OFFSET = unsafe.objectFieldOffset(abstractFuture.getDeclaredField("value"));</a>
-<span class="sourceLineNo">1388</span><a id="line.1388">        WAITER_THREAD_OFFSET = unsafe.objectFieldOffset(Waiter.class.getDeclaredField("thread"));</a>
-<span class="sourceLineNo">1389</span><a id="line.1389">        WAITER_NEXT_OFFSET = unsafe.objectFieldOffset(Waiter.class.getDeclaredField("next"));</a>
-<span class="sourceLineNo">1390</span><a id="line.1390">        UNSAFE = unsafe;</a>
-<span class="sourceLineNo">1391</span><a id="line.1391">      } catch (NoSuchFieldException e) {</a>
-<span class="sourceLineNo">1392</span><a id="line.1392">        throw new RuntimeException(e);</a>
-<span class="sourceLineNo">1393</span><a id="line.1393">      }</a>
-<span class="sourceLineNo">1394</span><a id="line.1394">    }</a>
-<span class="sourceLineNo">1395</span><a id="line.1395"></a>
-<span class="sourceLineNo">1396</span><a id="line.1396">    @Override</a>
-<span class="sourceLineNo">1397</span><a id="line.1397">    void putThread(Waiter waiter, Thread newValue) {</a>
-<span class="sourceLineNo">1398</span><a id="line.1398">      UNSAFE.putObject(waiter, WAITER_THREAD_OFFSET, newValue);</a>
-<span class="sourceLineNo">1399</span><a id="line.1399">    }</a>
-<span class="sourceLineNo">1400</span><a id="line.1400"></a>
-<span class="sourceLineNo">1401</span><a id="line.1401">    @Override</a>
-<span class="sourceLineNo">1402</span><a id="line.1402">    void putNext(Waiter waiter, @Nullable Waiter newValue) {</a>
-<span class="sourceLineNo">1403</span><a id="line.1403">      UNSAFE.putObject(waiter, WAITER_NEXT_OFFSET, newValue);</a>
-<span class="sourceLineNo">1404</span><a id="line.1404">    }</a>
-<span class="sourceLineNo">1405</span><a id="line.1405"></a>
-<span class="sourceLineNo">1406</span><a id="line.1406">    @Override</a>
-<span class="sourceLineNo">1407</span><a id="line.1407">    boolean casWaiters(AbstractFuture&lt;?&gt; future, @Nullable Waiter expect, @Nullable Waiter update) {</a>
-<span class="sourceLineNo">1408</span><a id="line.1408">      return UNSAFE.compareAndSwapObject(future, WAITERS_OFFSET, expect, update);</a>
-<span class="sourceLineNo">1409</span><a id="line.1409">    }</a>
-<span class="sourceLineNo">1410</span><a id="line.1410"></a>
-<span class="sourceLineNo">1411</span><a id="line.1411">    @Override</a>
-<span class="sourceLineNo">1412</span><a id="line.1412">    boolean casListeners(AbstractFuture&lt;?&gt; future, @Nullable Listener expect, Listener update) {</a>
-<span class="sourceLineNo">1413</span><a id="line.1413">      return UNSAFE.compareAndSwapObject(future, LISTENERS_OFFSET, expect, update);</a>
-<span class="sourceLineNo">1414</span><a id="line.1414">    }</a>
+<span class="sourceLineNo">1357</span><a id="line.1357">  /**</a>
+<span class="sourceLineNo">1358</span><a id="line.1358">   * Submits the given runnable to the given {@link Executor} catching and logging all {@linkplain</a>
+<span class="sourceLineNo">1359</span><a id="line.1359">   * RuntimeException runtime exceptions} thrown by the executor.</a>
+<span class="sourceLineNo">1360</span><a id="line.1360">   */</a>
+<span class="sourceLineNo">1361</span><a id="line.1361">  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception</a>
+<span class="sourceLineNo">1362</span><a id="line.1362">  private static void executeListener(Runnable runnable, Executor executor) {</a>
+<span class="sourceLineNo">1363</span><a id="line.1363">    try {</a>
+<span class="sourceLineNo">1364</span><a id="line.1364">      executor.execute(runnable);</a>
+<span class="sourceLineNo">1365</span><a id="line.1365">    } catch (Exception e) { // sneaky checked exception</a>
+<span class="sourceLineNo">1366</span><a id="line.1366">      // Log it and keep going -- bad runnable and/or executor. Don't punish the other runnables if</a>
+<span class="sourceLineNo">1367</span><a id="line.1367">      // we're given a bad one. We only catch Exception because we want Errors to propagate up.</a>
+<span class="sourceLineNo">1368</span><a id="line.1368">      log.get()</a>
+<span class="sourceLineNo">1369</span><a id="line.1369">          .log(</a>
+<span class="sourceLineNo">1370</span><a id="line.1370">              Level.SEVERE,</a>
+<span class="sourceLineNo">1371</span><a id="line.1371">              "RuntimeException while executing runnable "</a>
+<span class="sourceLineNo">1372</span><a id="line.1372">                  + runnable</a>
+<span class="sourceLineNo">1373</span><a id="line.1373">                  + " with executor "</a>
+<span class="sourceLineNo">1374</span><a id="line.1374">                  + executor,</a>
+<span class="sourceLineNo">1375</span><a id="line.1375">              e);</a>
+<span class="sourceLineNo">1376</span><a id="line.1376">    }</a>
+<span class="sourceLineNo">1377</span><a id="line.1377">  }</a>
+<span class="sourceLineNo">1378</span><a id="line.1378"></a>
+<span class="sourceLineNo">1379</span><a id="line.1379">  private abstract static class AtomicHelper {</a>
+<span class="sourceLineNo">1380</span><a id="line.1380">    /** Non-volatile write of the thread to the {@link Waiter#thread} field. */</a>
+<span class="sourceLineNo">1381</span><a id="line.1381">    abstract void putThread(Waiter waiter, Thread newValue);</a>
+<span class="sourceLineNo">1382</span><a id="line.1382"></a>
+<span class="sourceLineNo">1383</span><a id="line.1383">    /** Non-volatile write of the waiter to the {@link Waiter#next} field. */</a>
+<span class="sourceLineNo">1384</span><a id="line.1384">    abstract void putNext(Waiter waiter, @Nullable Waiter newValue);</a>
+<span class="sourceLineNo">1385</span><a id="line.1385"></a>
+<span class="sourceLineNo">1386</span><a id="line.1386">    /** Performs a CAS operation on the {@link AbstractFuture#waiters} field. */</a>
+<span class="sourceLineNo">1387</span><a id="line.1387">    abstract boolean casWaiters(</a>
+<span class="sourceLineNo">1388</span><a id="line.1388">        AbstractFuture&lt;?&gt; future, @Nullable Waiter expect, @Nullable Waiter update);</a>
+<span class="sourceLineNo">1389</span><a id="line.1389"></a>
+<span class="sourceLineNo">1390</span><a id="line.1390">    /** Performs a CAS operation on the {@link AbstractFuture#listeners} field. */</a>
+<span class="sourceLineNo">1391</span><a id="line.1391">    abstract boolean casListeners(</a>
+<span class="sourceLineNo">1392</span><a id="line.1392">        AbstractFuture&lt;?&gt; future, @Nullable Listener expect, Listener update);</a>
+<span class="sourceLineNo">1393</span><a id="line.1393"></a>
+<span class="sourceLineNo">1394</span><a id="line.1394">    /** Performs a GAS operation on the {@link AbstractFuture#waiters} field. */</a>
+<span class="sourceLineNo">1395</span><a id="line.1395">    abstract Waiter gasWaiters(AbstractFuture&lt;?&gt; future, Waiter update);</a>
+<span class="sourceLineNo">1396</span><a id="line.1396"></a>
+<span class="sourceLineNo">1397</span><a id="line.1397">    /** Performs a GAS operation on the {@link AbstractFuture#listeners} field. */</a>
+<span class="sourceLineNo">1398</span><a id="line.1398">    abstract Listener gasListeners(AbstractFuture&lt;?&gt; future, Listener update);</a>
+<span class="sourceLineNo">1399</span><a id="line.1399"></a>
+<span class="sourceLineNo">1400</span><a id="line.1400">    /** Performs a CAS operation on the {@link AbstractFuture#value} field. */</a>
+<span class="sourceLineNo">1401</span><a id="line.1401">    abstract boolean casValue(AbstractFuture&lt;?&gt; future, @Nullable Object expect, Object update);</a>
+<span class="sourceLineNo">1402</span><a id="line.1402">  }</a>
+<span class="sourceLineNo">1403</span><a id="line.1403"></a>
+<span class="sourceLineNo">1404</span><a id="line.1404">  /** {@link AtomicHelper} based on {@link VarHandle}. */</a>
+<span class="sourceLineNo">1405</span><a id="line.1405">  @J2ObjCIncompatible</a>
+<span class="sourceLineNo">1406</span><a id="line.1406">  // We use this class only after confirming that VarHandle is available at runtime.</a>
+<span class="sourceLineNo">1407</span><a id="line.1407">  @SuppressWarnings("Java8ApiChecker")</a>
+<span class="sourceLineNo">1408</span><a id="line.1408">  @IgnoreJRERequirement</a>
+<span class="sourceLineNo">1409</span><a id="line.1409">  private static final class VarHandleAtomicHelper extends AtomicHelper {</a>
+<span class="sourceLineNo">1410</span><a id="line.1410">    static final VarHandle waiterThreadUpdater;</a>
+<span class="sourceLineNo">1411</span><a id="line.1411">    static final VarHandle waiterNextUpdater;</a>
+<span class="sourceLineNo">1412</span><a id="line.1412">    static final VarHandle waitersUpdater;</a>
+<span class="sourceLineNo">1413</span><a id="line.1413">    static final VarHandle listenersUpdater;</a>
+<span class="sourceLineNo">1414</span><a id="line.1414">    static final VarHandle valueUpdater;</a>
 <span class="sourceLineNo">1415</span><a id="line.1415"></a>
-<span class="sourceLineNo">1416</span><a id="line.1416">    @Override</a>
-<span class="sourceLineNo">1417</span><a id="line.1417">    Listener gasListeners(AbstractFuture&lt;?&gt; future, Listener update) {</a>
-<span class="sourceLineNo">1418</span><a id="line.1418">      return (Listener) UNSAFE.getAndSetObject(future, LISTENERS_OFFSET, update);</a>
-<span class="sourceLineNo">1419</span><a id="line.1419">    }</a>
-<span class="sourceLineNo">1420</span><a id="line.1420"></a>
-<span class="sourceLineNo">1421</span><a id="line.1421">    @Override</a>
-<span class="sourceLineNo">1422</span><a id="line.1422">    Waiter gasWaiters(AbstractFuture&lt;?&gt; future, Waiter update) {</a>
-<span class="sourceLineNo">1423</span><a id="line.1423">      return (Waiter) UNSAFE.getAndSetObject(future, WAITERS_OFFSET, update);</a>
-<span class="sourceLineNo">1424</span><a id="line.1424">    }</a>
-<span class="sourceLineNo">1425</span><a id="line.1425"></a>
-<span class="sourceLineNo">1426</span><a id="line.1426">    @Override</a>
-<span class="sourceLineNo">1427</span><a id="line.1427">    boolean casValue(AbstractFuture&lt;?&gt; future, @Nullable Object expect, Object update) {</a>
-<span class="sourceLineNo">1428</span><a id="line.1428">      return UNSAFE.compareAndSwapObject(future, VALUE_OFFSET, expect, update);</a>
-<span class="sourceLineNo">1429</span><a id="line.1429">    }</a>
-<span class="sourceLineNo">1430</span><a id="line.1430">  }</a>
-<span class="sourceLineNo">1431</span><a id="line.1431"></a>
-<span class="sourceLineNo">1432</span><a id="line.1432">  /** {@link AtomicHelper} based on {@link AtomicReferenceFieldUpdater}. */</a>
-<span class="sourceLineNo">1433</span><a id="line.1433">  private static final class AtomicReferenceFieldUpdaterAtomicHelper extends AtomicHelper {</a>
-<span class="sourceLineNo">1434</span><a id="line.1434">    final AtomicReferenceFieldUpdater&lt;Waiter, Thread&gt; waiterThreadUpdater;</a>
-<span class="sourceLineNo">1435</span><a id="line.1435">    final AtomicReferenceFieldUpdater&lt;Waiter, Waiter&gt; waiterNextUpdater;</a>
-<span class="sourceLineNo">1436</span><a id="line.1436">    final AtomicReferenceFieldUpdater&lt;? super AbstractFuture&lt;?&gt;, Waiter&gt; waitersUpdater;</a>
-<span class="sourceLineNo">1437</span><a id="line.1437">    final AtomicReferenceFieldUpdater&lt;? super AbstractFuture&lt;?&gt;, Listener&gt; listenersUpdater;</a>
-<span class="sourceLineNo">1438</span><a id="line.1438">    final AtomicReferenceFieldUpdater&lt;? super AbstractFuture&lt;?&gt;, Object&gt; valueUpdater;</a>
+<span class="sourceLineNo">1416</span><a id="line.1416">    static {</a>
+<span class="sourceLineNo">1417</span><a id="line.1417">      MethodHandles.Lookup lookup = methodHandlesLookupFromWithinAbstractFuture();</a>
+<span class="sourceLineNo">1418</span><a id="line.1418">      try {</a>
+<span class="sourceLineNo">1419</span><a id="line.1419">        waiterThreadUpdater = lookup.findVarHandle(Waiter.class, "thread", Thread.class);</a>
+<span class="sourceLineNo">1420</span><a id="line.1420">        waiterNextUpdater = lookup.findVarHandle(Waiter.class, "next", Waiter.class);</a>
+<span class="sourceLineNo">1421</span><a id="line.1421">        waitersUpdater = lookup.findVarHandle(AbstractFuture.class, "waiters", Waiter.class);</a>
+<span class="sourceLineNo">1422</span><a id="line.1422">        listenersUpdater = lookup.findVarHandle(AbstractFuture.class, "listeners", Listener.class);</a>
+<span class="sourceLineNo">1423</span><a id="line.1423">        valueUpdater = lookup.findVarHandle(AbstractFuture.class, "value", Object.class);</a>
+<span class="sourceLineNo">1424</span><a id="line.1424">      } catch (ReflectiveOperationException e) {</a>
+<span class="sourceLineNo">1425</span><a id="line.1425">        // Those fields exist.</a>
+<span class="sourceLineNo">1426</span><a id="line.1426">        throw newLinkageError(e);</a>
+<span class="sourceLineNo">1427</span><a id="line.1427">      }</a>
+<span class="sourceLineNo">1428</span><a id="line.1428">    }</a>
+<span class="sourceLineNo">1429</span><a id="line.1429"></a>
+<span class="sourceLineNo">1430</span><a id="line.1430">    @Override</a>
+<span class="sourceLineNo">1431</span><a id="line.1431">    void putThread(Waiter waiter, Thread newValue) {</a>
+<span class="sourceLineNo">1432</span><a id="line.1432">      waiterThreadUpdater.setRelease(waiter, newValue);</a>
+<span class="sourceLineNo">1433</span><a id="line.1433">    }</a>
+<span class="sourceLineNo">1434</span><a id="line.1434"></a>
+<span class="sourceLineNo">1435</span><a id="line.1435">    @Override</a>
+<span class="sourceLineNo">1436</span><a id="line.1436">    void putNext(Waiter waiter, @Nullable Waiter newValue) {</a>
+<span class="sourceLineNo">1437</span><a id="line.1437">      waiterNextUpdater.setRelease(waiter, newValue);</a>
+<span class="sourceLineNo">1438</span><a id="line.1438">    }</a>
 <span class="sourceLineNo">1439</span><a id="line.1439"></a>
-<span class="sourceLineNo">1440</span><a id="line.1440">    AtomicReferenceFieldUpdaterAtomicHelper(</a>
-<span class="sourceLineNo">1441</span><a id="line.1441">        AtomicReferenceFieldUpdater&lt;Waiter, Thread&gt; waiterThreadUpdater,</a>
-<span class="sourceLineNo">1442</span><a id="line.1442">        AtomicReferenceFieldUpdater&lt;Waiter, Waiter&gt; waiterNextUpdater,</a>
-<span class="sourceLineNo">1443</span><a id="line.1443">        AtomicReferenceFieldUpdater&lt;? super AbstractFuture&lt;?&gt;, Waiter&gt; waitersUpdater,</a>
-<span class="sourceLineNo">1444</span><a id="line.1444">        AtomicReferenceFieldUpdater&lt;? super AbstractFuture&lt;?&gt;, Listener&gt; listenersUpdater,</a>
-<span class="sourceLineNo">1445</span><a id="line.1445">        AtomicReferenceFieldUpdater&lt;? super AbstractFuture&lt;?&gt;, Object&gt; valueUpdater) {</a>
-<span class="sourceLineNo">1446</span><a id="line.1446">      this.waiterThreadUpdater = waiterThreadUpdater;</a>
-<span class="sourceLineNo">1447</span><a id="line.1447">      this.waiterNextUpdater = waiterNextUpdater;</a>
-<span class="sourceLineNo">1448</span><a id="line.1448">      this.waitersUpdater = waitersUpdater;</a>
-<span class="sourceLineNo">1449</span><a id="line.1449">      this.listenersUpdater = listenersUpdater;</a>
-<span class="sourceLineNo">1450</span><a id="line.1450">      this.valueUpdater = valueUpdater;</a>
-<span class="sourceLineNo">1451</span><a id="line.1451">    }</a>
-<span class="sourceLineNo">1452</span><a id="line.1452"></a>
-<span class="sourceLineNo">1453</span><a id="line.1453">    @Override</a>
-<span class="sourceLineNo">1454</span><a id="line.1454">    void putThread(Waiter waiter, Thread newValue) {</a>
-<span class="sourceLineNo">1455</span><a id="line.1455">      waiterThreadUpdater.lazySet(waiter, newValue);</a>
-<span class="sourceLineNo">1456</span><a id="line.1456">    }</a>
-<span class="sourceLineNo">1457</span><a id="line.1457"></a>
-<span class="sourceLineNo">1458</span><a id="line.1458">    @Override</a>
-<span class="sourceLineNo">1459</span><a id="line.1459">    void putNext(Waiter waiter, @Nullable Waiter newValue) {</a>
-<span class="sourceLineNo">1460</span><a id="line.1460">      waiterNextUpdater.lazySet(waiter, newValue);</a>
-<span class="sourceLineNo">1461</span><a id="line.1461">    }</a>
-<span class="sourceLineNo">1462</span><a id="line.1462"></a>
-<span class="sourceLineNo">1463</span><a id="line.1463">    @Override</a>
-<span class="sourceLineNo">1464</span><a id="line.1464">    boolean casWaiters(AbstractFuture&lt;?&gt; future, @Nullable Waiter expect, @Nullable Waiter update) {</a>
-<span class="sourceLineNo">1465</span><a id="line.1465">      return waitersUpdater.compareAndSet(future, expect, update);</a>
-<span class="sourceLineNo">1466</span><a id="line.1466">    }</a>
-<span class="sourceLineNo">1467</span><a id="line.1467"></a>
-<span class="sourceLineNo">1468</span><a id="line.1468">    @Override</a>
-<span class="sourceLineNo">1469</span><a id="line.1469">    boolean casListeners(AbstractFuture&lt;?&gt; future, @Nullable Listener expect, Listener update) {</a>
-<span class="sourceLineNo">1470</span><a id="line.1470">      return listenersUpdater.compareAndSet(future, expect, update);</a>
-<span class="sourceLineNo">1471</span><a id="line.1471">    }</a>
-<span class="sourceLineNo">1472</span><a id="line.1472"></a>
-<span class="sourceLineNo">1473</span><a id="line.1473">    @Override</a>
-<span class="sourceLineNo">1474</span><a id="line.1474">    Listener gasListeners(AbstractFuture&lt;?&gt; future, Listener update) {</a>
-<span class="sourceLineNo">1475</span><a id="line.1475">      return listenersUpdater.getAndSet(future, update);</a>
-<span class="sourceLineNo">1476</span><a id="line.1476">    }</a>
-<span class="sourceLineNo">1477</span><a id="line.1477"></a>
-<span class="sourceLineNo">1478</span><a id="line.1478">    @Override</a>
-<span class="sourceLineNo">1479</span><a id="line.1479">    Waiter gasWaiters(AbstractFuture&lt;?&gt; future, Waiter update) {</a>
-<span class="sourceLineNo">1480</span><a id="line.1480">      return waitersUpdater.getAndSet(future, update);</a>
-<span class="sourceLineNo">1481</span><a id="line.1481">    }</a>
-<span class="sourceLineNo">1482</span><a id="line.1482"></a>
-<span class="sourceLineNo">1483</span><a id="line.1483">    @Override</a>
-<span class="sourceLineNo">1484</span><a id="line.1484">    boolean casValue(AbstractFuture&lt;?&gt; future, @Nullable Object expect, Object update) {</a>
-<span class="sourceLineNo">1485</span><a id="line.1485">      return valueUpdater.compareAndSet(future, expect, update);</a>
-<span class="sourceLineNo">1486</span><a id="line.1486">    }</a>
-<span class="sourceLineNo">1487</span><a id="line.1487">  }</a>
-<span class="sourceLineNo">1488</span><a id="line.1488"></a>
-<span class="sourceLineNo">1489</span><a id="line.1489">  /**</a>
-<span class="sourceLineNo">1490</span><a id="line.1490">   * {@link AtomicHelper} based on {@code synchronized} and volatile writes.</a>
-<span class="sourceLineNo">1491</span><a id="line.1491">   *</a>
-<span class="sourceLineNo">1492</span><a id="line.1492">   * &lt;p&gt;This is an implementation of last resort for when certain basic VM features are broken (like</a>
-<span class="sourceLineNo">1493</span><a id="line.1493">   * AtomicReferenceFieldUpdater).</a>
-<span class="sourceLineNo">1494</span><a id="line.1494">   */</a>
-<span class="sourceLineNo">1495</span><a id="line.1495">  private static final class SynchronizedHelper extends AtomicHelper {</a>
-<span class="sourceLineNo">1496</span><a id="line.1496">    @Override</a>
-<span class="sourceLineNo">1497</span><a id="line.1497">    void putThread(Waiter waiter, Thread newValue) {</a>
-<span class="sourceLineNo">1498</span><a id="line.1498">      waiter.thread = newValue;</a>
-<span class="sourceLineNo">1499</span><a id="line.1499">    }</a>
-<span class="sourceLineNo">1500</span><a id="line.1500"></a>
-<span class="sourceLineNo">1501</span><a id="line.1501">    @Override</a>
-<span class="sourceLineNo">1502</span><a id="line.1502">    void putNext(Waiter waiter, @Nullable Waiter newValue) {</a>
-<span class="sourceLineNo">1503</span><a id="line.1503">      waiter.next = newValue;</a>
-<span class="sourceLineNo">1504</span><a id="line.1504">    }</a>
-<span class="sourceLineNo">1505</span><a id="line.1505"></a>
-<span class="sourceLineNo">1506</span><a id="line.1506">    @Override</a>
-<span class="sourceLineNo">1507</span><a id="line.1507">    boolean casWaiters(AbstractFuture&lt;?&gt; future, @Nullable Waiter expect, @Nullable Waiter update) {</a>
-<span class="sourceLineNo">1508</span><a id="line.1508">      synchronized (future) {</a>
-<span class="sourceLineNo">1509</span><a id="line.1509">        if (future.waiters == expect) {</a>
-<span class="sourceLineNo">1510</span><a id="line.1510">          future.waiters = update;</a>
-<span class="sourceLineNo">1511</span><a id="line.1511">          return true;</a>
-<span class="sourceLineNo">1512</span><a id="line.1512">        }</a>
-<span class="sourceLineNo">1513</span><a id="line.1513">        return false;</a>
-<span class="sourceLineNo">1514</span><a id="line.1514">      }</a>
-<span class="sourceLineNo">1515</span><a id="line.1515">    }</a>
-<span class="sourceLineNo">1516</span><a id="line.1516"></a>
-<span class="sourceLineNo">1517</span><a id="line.1517">    @Override</a>
-<span class="sourceLineNo">1518</span><a id="line.1518">    boolean casListeners(AbstractFuture&lt;?&gt; future, @Nullable Listener expect, Listener update) {</a>
-<span class="sourceLineNo">1519</span><a id="line.1519">      synchronized (future) {</a>
-<span class="sourceLineNo">1520</span><a id="line.1520">        if (future.listeners == expect) {</a>
-<span class="sourceLineNo">1521</span><a id="line.1521">          future.listeners = update;</a>
-<span class="sourceLineNo">1522</span><a id="line.1522">          return true;</a>
-<span class="sourceLineNo">1523</span><a id="line.1523">        }</a>
-<span class="sourceLineNo">1524</span><a id="line.1524">        return false;</a>
-<span class="sourceLineNo">1525</span><a id="line.1525">      }</a>
-<span class="sourceLineNo">1526</span><a id="line.1526">    }</a>
-<span class="sourceLineNo">1527</span><a id="line.1527"></a>
-<span class="sourceLineNo">1528</span><a id="line.1528">    @Override</a>
-<span class="sourceLineNo">1529</span><a id="line.1529">    Listener gasListeners(AbstractFuture&lt;?&gt; future, Listener update) {</a>
-<span class="sourceLineNo">1530</span><a id="line.1530">      synchronized (future) {</a>
-<span class="sourceLineNo">1531</span><a id="line.1531">        Listener old = future.listeners;</a>
-<span class="sourceLineNo">1532</span><a id="line.1532">        if (old != update) {</a>
-<span class="sourceLineNo">1533</span><a id="line.1533">          future.listeners = update;</a>
-<span class="sourceLineNo">1534</span><a id="line.1534">        }</a>
-<span class="sourceLineNo">1535</span><a id="line.1535">        return old;</a>
-<span class="sourceLineNo">1536</span><a id="line.1536">      }</a>
+<span class="sourceLineNo">1440</span><a id="line.1440">    @Override</a>
+<span class="sourceLineNo">1441</span><a id="line.1441">    boolean casWaiters(AbstractFuture&lt;?&gt; future, @Nullable Waiter expect, @Nullable Waiter update) {</a>
+<span class="sourceLineNo">1442</span><a id="line.1442">      return waitersUpdater.compareAndSet(future, expect, update);</a>
+<span class="sourceLineNo">1443</span><a id="line.1443">    }</a>
+<span class="sourceLineNo">1444</span><a id="line.1444"></a>
+<span class="sourceLineNo">1445</span><a id="line.1445">    @Override</a>
+<span class="sourceLineNo">1446</span><a id="line.1446">    boolean casListeners(AbstractFuture&lt;?&gt; future, @Nullable Listener expect, Listener update) {</a>
+<span class="sourceLineNo">1447</span><a id="line.1447">      return listenersUpdater.compareAndSet(future, expect, update);</a>
+<span class="sourceLineNo">1448</span><a id="line.1448">    }</a>
+<span class="sourceLineNo">1449</span><a id="line.1449"></a>
+<span class="sourceLineNo">1450</span><a id="line.1450">    @Override</a>
+<span class="sourceLineNo">1451</span><a id="line.1451">    Listener gasListeners(AbstractFuture&lt;?&gt; future, Listener update) {</a>
+<span class="sourceLineNo">1452</span><a id="line.1452">      return (Listener) listenersUpdater.getAndSet(future, update);</a>
+<span class="sourceLineNo">1453</span><a id="line.1453">    }</a>
+<span class="sourceLineNo">1454</span><a id="line.1454"></a>
+<span class="sourceLineNo">1455</span><a id="line.1455">    @Override</a>
+<span class="sourceLineNo">1456</span><a id="line.1456">    Waiter gasWaiters(AbstractFuture&lt;?&gt; future, Waiter update) {</a>
+<span class="sourceLineNo">1457</span><a id="line.1457">      return (Waiter) waitersUpdater.getAndSet(future, update);</a>
+<span class="sourceLineNo">1458</span><a id="line.1458">    }</a>
+<span class="sourceLineNo">1459</span><a id="line.1459"></a>
+<span class="sourceLineNo">1460</span><a id="line.1460">    @Override</a>
+<span class="sourceLineNo">1461</span><a id="line.1461">    boolean casValue(AbstractFuture&lt;?&gt; future, @Nullable Object expect, Object update) {</a>
+<span class="sourceLineNo">1462</span><a id="line.1462">      return valueUpdater.compareAndSet(future, expect, update);</a>
+<span class="sourceLineNo">1463</span><a id="line.1463">    }</a>
+<span class="sourceLineNo">1464</span><a id="line.1464"></a>
+<span class="sourceLineNo">1465</span><a id="line.1465">    private static LinkageError newLinkageError(Throwable cause) {</a>
+<span class="sourceLineNo">1466</span><a id="line.1466">      return new LinkageError(cause.toString(), cause);</a>
+<span class="sourceLineNo">1467</span><a id="line.1467">    }</a>
+<span class="sourceLineNo">1468</span><a id="line.1468">  }</a>
+<span class="sourceLineNo">1469</span><a id="line.1469"></a>
+<span class="sourceLineNo">1470</span><a id="line.1470">  /**</a>
+<span class="sourceLineNo">1471</span><a id="line.1471">   * {@link AtomicHelper} based on {@link sun.misc.Unsafe}.</a>
+<span class="sourceLineNo">1472</span><a id="line.1472">   *</a>
+<span class="sourceLineNo">1473</span><a id="line.1473">   * &lt;p&gt;Static initialization of this class will fail if the {@link sun.misc.Unsafe} object cannot</a>
+<span class="sourceLineNo">1474</span><a id="line.1474">   * be accessed.</a>
+<span class="sourceLineNo">1475</span><a id="line.1475">   */</a>
+<span class="sourceLineNo">1476</span><a id="line.1476">  @SuppressWarnings({"SunApi", "removal"}) // b/345822163</a>
+<span class="sourceLineNo">1477</span><a id="line.1477">  private static final class UnsafeAtomicHelper extends AtomicHelper {</a>
+<span class="sourceLineNo">1478</span><a id="line.1478">    static final Unsafe UNSAFE;</a>
+<span class="sourceLineNo">1479</span><a id="line.1479">    static final long LISTENERS_OFFSET;</a>
+<span class="sourceLineNo">1480</span><a id="line.1480">    static final long WAITERS_OFFSET;</a>
+<span class="sourceLineNo">1481</span><a id="line.1481">    static final long VALUE_OFFSET;</a>
+<span class="sourceLineNo">1482</span><a id="line.1482">    static final long WAITER_THREAD_OFFSET;</a>
+<span class="sourceLineNo">1483</span><a id="line.1483">    static final long WAITER_NEXT_OFFSET;</a>
+<span class="sourceLineNo">1484</span><a id="line.1484"></a>
+<span class="sourceLineNo">1485</span><a id="line.1485">    static {</a>
+<span class="sourceLineNo">1486</span><a id="line.1486">      Unsafe unsafe = null;</a>
+<span class="sourceLineNo">1487</span><a id="line.1487">      try {</a>
+<span class="sourceLineNo">1488</span><a id="line.1488">        unsafe = Unsafe.getUnsafe();</a>
+<span class="sourceLineNo">1489</span><a id="line.1489">      } catch (SecurityException tryReflectionInstead) {</a>
+<span class="sourceLineNo">1490</span><a id="line.1490">        try {</a>
+<span class="sourceLineNo">1491</span><a id="line.1491">          unsafe =</a>
+<span class="sourceLineNo">1492</span><a id="line.1492">              AccessController.doPrivileged(</a>
+<span class="sourceLineNo">1493</span><a id="line.1493">                  new PrivilegedExceptionAction&lt;Unsafe&gt;() {</a>
+<span class="sourceLineNo">1494</span><a id="line.1494">                    @Override</a>
+<span class="sourceLineNo">1495</span><a id="line.1495">                    public Unsafe run() throws Exception {</a>
+<span class="sourceLineNo">1496</span><a id="line.1496">                      Class&lt;Unsafe&gt; k = Unsafe.class;</a>
+<span class="sourceLineNo">1497</span><a id="line.1497">                      for (Field f : k.getDeclaredFields()) {</a>
+<span class="sourceLineNo">1498</span><a id="line.1498">                        f.setAccessible(true);</a>
+<span class="sourceLineNo">1499</span><a id="line.1499">                        Object x = f.get(null);</a>
+<span class="sourceLineNo">1500</span><a id="line.1500">                        if (k.isInstance(x)) {</a>
+<span class="sourceLineNo">1501</span><a id="line.1501">                          return k.cast(x);</a>
+<span class="sourceLineNo">1502</span><a id="line.1502">                        }</a>
+<span class="sourceLineNo">1503</span><a id="line.1503">                      }</a>
+<span class="sourceLineNo">1504</span><a id="line.1504">                      throw new NoSuchFieldError("the Unsafe");</a>
+<span class="sourceLineNo">1505</span><a id="line.1505">                    }</a>
+<span class="sourceLineNo">1506</span><a id="line.1506">                  });</a>
+<span class="sourceLineNo">1507</span><a id="line.1507">        } catch (PrivilegedActionException e) {</a>
+<span class="sourceLineNo">1508</span><a id="line.1508">          throw new RuntimeException("Could not initialize intrinsics", e.getCause());</a>
+<span class="sourceLineNo">1509</span><a id="line.1509">        }</a>
+<span class="sourceLineNo">1510</span><a id="line.1510">      }</a>
+<span class="sourceLineNo">1511</span><a id="line.1511">      try {</a>
+<span class="sourceLineNo">1512</span><a id="line.1512">        Class&lt;?&gt; abstractFuture = AbstractFuture.class;</a>
+<span class="sourceLineNo">1513</span><a id="line.1513">        WAITERS_OFFSET = unsafe.objectFieldOffset(abstractFuture.getDeclaredField("waiters"));</a>
+<span class="sourceLineNo">1514</span><a id="line.1514">        LISTENERS_OFFSET = unsafe.objectFieldOffset(abstractFuture.getDeclaredField("listeners"));</a>
+<span class="sourceLineNo">1515</span><a id="line.1515">        VALUE_OFFSET = unsafe.objectFieldOffset(abstractFuture.getDeclaredField("value"));</a>
+<span class="sourceLineNo">1516</span><a id="line.1516">        WAITER_THREAD_OFFSET = unsafe.objectFieldOffset(Waiter.class.getDeclaredField("thread"));</a>
+<span class="sourceLineNo">1517</span><a id="line.1517">        WAITER_NEXT_OFFSET = unsafe.objectFieldOffset(Waiter.class.getDeclaredField("next"));</a>
+<span class="sourceLineNo">1518</span><a id="line.1518">        UNSAFE = unsafe;</a>
+<span class="sourceLineNo">1519</span><a id="line.1519">      } catch (NoSuchFieldException e) {</a>
+<span class="sourceLineNo">1520</span><a id="line.1520">        throw new RuntimeException(e);</a>
+<span class="sourceLineNo">1521</span><a id="line.1521">      }</a>
+<span class="sourceLineNo">1522</span><a id="line.1522">    }</a>
+<span class="sourceLineNo">1523</span><a id="line.1523"></a>
+<span class="sourceLineNo">1524</span><a id="line.1524">    @Override</a>
+<span class="sourceLineNo">1525</span><a id="line.1525">    void putThread(Waiter waiter, Thread newValue) {</a>
+<span class="sourceLineNo">1526</span><a id="line.1526">      UNSAFE.putObject(waiter, WAITER_THREAD_OFFSET, newValue);</a>
+<span class="sourceLineNo">1527</span><a id="line.1527">    }</a>
+<span class="sourceLineNo">1528</span><a id="line.1528"></a>
+<span class="sourceLineNo">1529</span><a id="line.1529">    @Override</a>
+<span class="sourceLineNo">1530</span><a id="line.1530">    void putNext(Waiter waiter, @Nullable Waiter newValue) {</a>
+<span class="sourceLineNo">1531</span><a id="line.1531">      UNSAFE.putObject(waiter, WAITER_NEXT_OFFSET, newValue);</a>
+<span class="sourceLineNo">1532</span><a id="line.1532">    }</a>
+<span class="sourceLineNo">1533</span><a id="line.1533"></a>
+<span class="sourceLineNo">1534</span><a id="line.1534">    @Override</a>
+<span class="sourceLineNo">1535</span><a id="line.1535">    boolean casWaiters(AbstractFuture&lt;?&gt; future, @Nullable Waiter expect, @Nullable Waiter update) {</a>
+<span class="sourceLineNo">1536</span><a id="line.1536">      return UNSAFE.compareAndSwapObject(future, WAITERS_OFFSET, expect, update);</a>
 <span class="sourceLineNo">1537</span><a id="line.1537">    }</a>
 <span class="sourceLineNo">1538</span><a id="line.1538"></a>
 <span class="sourceLineNo">1539</span><a id="line.1539">    @Override</a>
-<span class="sourceLineNo">1540</span><a id="line.1540">    Waiter gasWaiters(AbstractFuture&lt;?&gt; future, Waiter update) {</a>
-<span class="sourceLineNo">1541</span><a id="line.1541">      synchronized (future) {</a>
-<span class="sourceLineNo">1542</span><a id="line.1542">        Waiter old = future.waiters;</a>
-<span class="sourceLineNo">1543</span><a id="line.1543">        if (old != update) {</a>
-<span class="sourceLineNo">1544</span><a id="line.1544">          future.waiters = update;</a>
-<span class="sourceLineNo">1545</span><a id="line.1545">        }</a>
-<span class="sourceLineNo">1546</span><a id="line.1546">        return old;</a>
-<span class="sourceLineNo">1547</span><a id="line.1547">      }</a>
-<span class="sourceLineNo">1548</span><a id="line.1548">    }</a>
-<span class="sourceLineNo">1549</span><a id="line.1549"></a>
-<span class="sourceLineNo">1550</span><a id="line.1550">    @Override</a>
-<span class="sourceLineNo">1551</span><a id="line.1551">    boolean casValue(AbstractFuture&lt;?&gt; future, @Nullable Object expect, Object update) {</a>
-<span class="sourceLineNo">1552</span><a id="line.1552">      synchronized (future) {</a>
-<span class="sourceLineNo">1553</span><a id="line.1553">        if (future.value == expect) {</a>
-<span class="sourceLineNo">1554</span><a id="line.1554">          future.value = update;</a>
-<span class="sourceLineNo">1555</span><a id="line.1555">          return true;</a>
-<span class="sourceLineNo">1556</span><a id="line.1556">        }</a>
-<span class="sourceLineNo">1557</span><a id="line.1557">        return false;</a>
-<span class="sourceLineNo">1558</span><a id="line.1558">      }</a>
-<span class="sourceLineNo">1559</span><a id="line.1559">    }</a>
-<span class="sourceLineNo">1560</span><a id="line.1560">  }</a>
-<span class="sourceLineNo">1561</span><a id="line.1561"></a>
-<span class="sourceLineNo">1562</span><a id="line.1562">  private static CancellationException cancellationExceptionWithCause(</a>
-<span class="sourceLineNo">1563</span><a id="line.1563">      String message, @Nullable Throwable cause) {</a>
-<span class="sourceLineNo">1564</span><a id="line.1564">    CancellationException exception = new CancellationException(message);</a>
-<span class="sourceLineNo">1565</span><a id="line.1565">    exception.initCause(cause);</a>
-<span class="sourceLineNo">1566</span><a id="line.1566">    return exception;</a>
-<span class="sourceLineNo">1567</span><a id="line.1567">  }</a>
-<span class="sourceLineNo">1568</span><a id="line.1568">}</a>
+<span class="sourceLineNo">1540</span><a id="line.1540">    boolean casListeners(AbstractFuture&lt;?&gt; future, @Nullable Listener expect, Listener update) {</a>
+<span class="sourceLineNo">1541</span><a id="line.1541">      return UNSAFE.compareAndSwapObject(future, LISTENERS_OFFSET, expect, update);</a>
+<span class="sourceLineNo">1542</span><a id="line.1542">    }</a>
+<span class="sourceLineNo">1543</span><a id="line.1543"></a>
+<span class="sourceLineNo">1544</span><a id="line.1544">    @Override</a>
+<span class="sourceLineNo">1545</span><a id="line.1545">    Listener gasListeners(AbstractFuture&lt;?&gt; future, Listener update) {</a>
+<span class="sourceLineNo">1546</span><a id="line.1546">      return (Listener) UNSAFE.getAndSetObject(future, LISTENERS_OFFSET, update);</a>
+<span class="sourceLineNo">1547</span><a id="line.1547">    }</a>
+<span class="sourceLineNo">1548</span><a id="line.1548"></a>
+<span class="sourceLineNo">1549</span><a id="line.1549">    @Override</a>
+<span class="sourceLineNo">1550</span><a id="line.1550">    Waiter gasWaiters(AbstractFuture&lt;?&gt; future, Waiter update) {</a>
+<span class="sourceLineNo">1551</span><a id="line.1551">      return (Waiter) UNSAFE.getAndSetObject(future, WAITERS_OFFSET, update);</a>
+<span class="sourceLineNo">1552</span><a id="line.1552">    }</a>
+<span class="sourceLineNo">1553</span><a id="line.1553"></a>
+<span class="sourceLineNo">1554</span><a id="line.1554">    @Override</a>
+<span class="sourceLineNo">1555</span><a id="line.1555">    boolean casValue(AbstractFuture&lt;?&gt; future, @Nullable Object expect, Object update) {</a>
+<span class="sourceLineNo">1556</span><a id="line.1556">      return UNSAFE.compareAndSwapObject(future, VALUE_OFFSET, expect, update);</a>
+<span class="sourceLineNo">1557</span><a id="line.1557">    }</a>
+<span class="sourceLineNo">1558</span><a id="line.1558">  }</a>
+<span class="sourceLineNo">1559</span><a id="line.1559"></a>
+<span class="sourceLineNo">1560</span><a id="line.1560">  /** {@link AtomicHelper} based on {@link AtomicReferenceFieldUpdater}. */</a>
+<span class="sourceLineNo">1561</span><a id="line.1561">  private static final class AtomicReferenceFieldUpdaterAtomicHelper extends AtomicHelper {</a>
+<span class="sourceLineNo">1562</span><a id="line.1562">    final AtomicReferenceFieldUpdater&lt;Waiter, Thread&gt; waiterThreadUpdater;</a>
+<span class="sourceLineNo">1563</span><a id="line.1563">    final AtomicReferenceFieldUpdater&lt;Waiter, Waiter&gt; waiterNextUpdater;</a>
+<span class="sourceLineNo">1564</span><a id="line.1564">    final AtomicReferenceFieldUpdater&lt;? super AbstractFuture&lt;?&gt;, Waiter&gt; waitersUpdater;</a>
+<span class="sourceLineNo">1565</span><a id="line.1565">    final AtomicReferenceFieldUpdater&lt;? super AbstractFuture&lt;?&gt;, Listener&gt; listenersUpdater;</a>
+<span class="sourceLineNo">1566</span><a id="line.1566">    final AtomicReferenceFieldUpdater&lt;? super AbstractFuture&lt;?&gt;, Object&gt; valueUpdater;</a>
+<span class="sourceLineNo">1567</span><a id="line.1567"></a>
+<span class="sourceLineNo">1568</span><a id="line.1568">    AtomicReferenceFieldUpdaterAtomicHelper(</a>
+<span class="sourceLineNo">1569</span><a id="line.1569">        AtomicReferenceFieldUpdater&lt;Waiter, Thread&gt; waiterThreadUpdater,</a>
+<span class="sourceLineNo">1570</span><a id="line.1570">        AtomicReferenceFieldUpdater&lt;Waiter, Waiter&gt; waiterNextUpdater,</a>
+<span class="sourceLineNo">1571</span><a id="line.1571">        AtomicReferenceFieldUpdater&lt;? super AbstractFuture&lt;?&gt;, Waiter&gt; waitersUpdater,</a>
+<span class="sourceLineNo">1572</span><a id="line.1572">        AtomicReferenceFieldUpdater&lt;? super AbstractFuture&lt;?&gt;, Listener&gt; listenersUpdater,</a>
+<span class="sourceLineNo">1573</span><a id="line.1573">        AtomicReferenceFieldUpdater&lt;? super AbstractFuture&lt;?&gt;, Object&gt; valueUpdater) {</a>
+<span class="sourceLineNo">1574</span><a id="line.1574">      this.waiterThreadUpdater = waiterThreadUpdater;</a>
+<span class="sourceLineNo">1575</span><a id="line.1575">      this.waiterNextUpdater = waiterNextUpdater;</a>
+<span class="sourceLineNo">1576</span><a id="line.1576">      this.waitersUpdater = waitersUpdater;</a>
+<span class="sourceLineNo">1577</span><a id="line.1577">      this.listenersUpdater = listenersUpdater;</a>
+<span class="sourceLineNo">1578</span><a id="line.1578">      this.valueUpdater = valueUpdater;</a>
+<span class="sourceLineNo">1579</span><a id="line.1579">    }</a>
+<span class="sourceLineNo">1580</span><a id="line.1580"></a>
+<span class="sourceLineNo">1581</span><a id="line.1581">    @Override</a>
+<span class="sourceLineNo">1582</span><a id="line.1582">    void putThread(Waiter waiter, Thread newValue) {</a>
+<span class="sourceLineNo">1583</span><a id="line.1583">      waiterThreadUpdater.lazySet(waiter, newValue);</a>
+<span class="sourceLineNo">1584</span><a id="line.1584">    }</a>
+<span class="sourceLineNo">1585</span><a id="line.1585"></a>
+<span class="sourceLineNo">1586</span><a id="line.1586">    @Override</a>
+<span class="sourceLineNo">1587</span><a id="line.1587">    void putNext(Waiter waiter, @Nullable Waiter newValue) {</a>
+<span class="sourceLineNo">1588</span><a id="line.1588">      waiterNextUpdater.lazySet(waiter, newValue);</a>
+<span class="sourceLineNo">1589</span><a id="line.1589">    }</a>
+<span class="sourceLineNo">1590</span><a id="line.1590"></a>
+<span class="sourceLineNo">1591</span><a id="line.1591">    @Override</a>
+<span class="sourceLineNo">1592</span><a id="line.1592">    boolean casWaiters(AbstractFuture&lt;?&gt; future, @Nullable Waiter expect, @Nullable Waiter update) {</a>
+<span class="sourceLineNo">1593</span><a id="line.1593">      return waitersUpdater.compareAndSet(future, expect, update);</a>
+<span class="sourceLineNo">1594</span><a id="line.1594">    }</a>
+<span class="sourceLineNo">1595</span><a id="line.1595"></a>
+<span class="sourceLineNo">1596</span><a id="line.1596">    @Override</a>
+<span class="sourceLineNo">1597</span><a id="line.1597">    boolean casListeners(AbstractFuture&lt;?&gt; future, @Nullable Listener expect, Listener update) {</a>
+<span class="sourceLineNo">1598</span><a id="line.1598">      return listenersUpdater.compareAndSet(future, expect, update);</a>
+<span class="sourceLineNo">1599</span><a id="line.1599">    }</a>
+<span class="sourceLineNo">1600</span><a id="line.1600"></a>
+<span class="sourceLineNo">1601</span><a id="line.1601">    @Override</a>
+<span class="sourceLineNo">1602</span><a id="line.1602">    Listener gasListeners(AbstractFuture&lt;?&gt; future, Listener update) {</a>
+<span class="sourceLineNo">1603</span><a id="line.1603">      return listenersUpdater.getAndSet(future, update);</a>
+<span class="sourceLineNo">1604</span><a id="line.1604">    }</a>
+<span class="sourceLineNo">1605</span><a id="line.1605"></a>
+<span class="sourceLineNo">1606</span><a id="line.1606">    @Override</a>
+<span class="sourceLineNo">1607</span><a id="line.1607">    Waiter gasWaiters(AbstractFuture&lt;?&gt; future, Waiter update) {</a>
+<span class="sourceLineNo">1608</span><a id="line.1608">      return waitersUpdater.getAndSet(future, update);</a>
+<span class="sourceLineNo">1609</span><a id="line.1609">    }</a>
+<span class="sourceLineNo">1610</span><a id="line.1610"></a>
+<span class="sourceLineNo">1611</span><a id="line.1611">    @Override</a>
+<span class="sourceLineNo">1612</span><a id="line.1612">    boolean casValue(AbstractFuture&lt;?&gt; future, @Nullable Object expect, Object update) {</a>
+<span class="sourceLineNo">1613</span><a id="line.1613">      return valueUpdater.compareAndSet(future, expect, update);</a>
+<span class="sourceLineNo">1614</span><a id="line.1614">    }</a>
+<span class="sourceLineNo">1615</span><a id="line.1615">  }</a>
+<span class="sourceLineNo">1616</span><a id="line.1616"></a>
+<span class="sourceLineNo">1617</span><a id="line.1617">  /**</a>
+<span class="sourceLineNo">1618</span><a id="line.1618">   * {@link AtomicHelper} based on {@code synchronized} and volatile writes.</a>
+<span class="sourceLineNo">1619</span><a id="line.1619">   *</a>
+<span class="sourceLineNo">1620</span><a id="line.1620">   * &lt;p&gt;This is an implementation of last resort for when certain basic VM features are broken (like</a>
+<span class="sourceLineNo">1621</span><a id="line.1621">   * AtomicReferenceFieldUpdater).</a>
+<span class="sourceLineNo">1622</span><a id="line.1622">   */</a>
+<span class="sourceLineNo">1623</span><a id="line.1623">  private static final class SynchronizedHelper extends AtomicHelper {</a>
+<span class="sourceLineNo">1624</span><a id="line.1624">    @Override</a>
+<span class="sourceLineNo">1625</span><a id="line.1625">    void putThread(Waiter waiter, Thread newValue) {</a>
+<span class="sourceLineNo">1626</span><a id="line.1626">      waiter.thread = newValue;</a>
+<span class="sourceLineNo">1627</span><a id="line.1627">    }</a>
+<span class="sourceLineNo">1628</span><a id="line.1628"></a>
+<span class="sourceLineNo">1629</span><a id="line.1629">    @Override</a>
+<span class="sourceLineNo">1630</span><a id="line.1630">    void putNext(Waiter waiter, @Nullable Waiter newValue) {</a>
+<span class="sourceLineNo">1631</span><a id="line.1631">      waiter.next = newValue;</a>
+<span class="sourceLineNo">1632</span><a id="line.1632">    }</a>
+<span class="sourceLineNo">1633</span><a id="line.1633"></a>
+<span class="sourceLineNo">1634</span><a id="line.1634">    @Override</a>
+<span class="sourceLineNo">1635</span><a id="line.1635">    boolean casWaiters(AbstractFuture&lt;?&gt; future, @Nullable Waiter expect, @Nullable Waiter update) {</a>
+<span class="sourceLineNo">1636</span><a id="line.1636">      synchronized (future) {</a>
+<span class="sourceLineNo">1637</span><a id="line.1637">        if (future.waiters == expect) {</a>
+<span class="sourceLineNo">1638</span><a id="line.1638">          future.waiters = update;</a>
+<span class="sourceLineNo">1639</span><a id="line.1639">          return true;</a>
+<span class="sourceLineNo">1640</span><a id="line.1640">        }</a>
+<span class="sourceLineNo">1641</span><a id="line.1641">        return false;</a>
+<span class="sourceLineNo">1642</span><a id="line.1642">      }</a>
+<span class="sourceLineNo">1643</span><a id="line.1643">    }</a>
+<span class="sourceLineNo">1644</span><a id="line.1644"></a>
+<span class="sourceLineNo">1645</span><a id="line.1645">    @Override</a>
+<span class="sourceLineNo">1646</span><a id="line.1646">    boolean casListeners(AbstractFuture&lt;?&gt; future, @Nullable Listener expect, Listener update) {</a>
+<span class="sourceLineNo">1647</span><a id="line.1647">      synchronized (future) {</a>
+<span class="sourceLineNo">1648</span><a id="line.1648">        if (future.listeners == expect) {</a>
+<span class="sourceLineNo">1649</span><a id="line.1649">          future.listeners = update;</a>
+<span class="sourceLineNo">1650</span><a id="line.1650">          return true;</a>
+<span class="sourceLineNo">1651</span><a id="line.1651">        }</a>
+<span class="sourceLineNo">1652</span><a id="line.1652">        return false;</a>
+<span class="sourceLineNo">1653</span><a id="line.1653">      }</a>
+<span class="sourceLineNo">1654</span><a id="line.1654">    }</a>
+<span class="sourceLineNo">1655</span><a id="line.1655"></a>
+<span class="sourceLineNo">1656</span><a id="line.1656">    @Override</a>
+<span class="sourceLineNo">1657</span><a id="line.1657">    Listener gasListeners(AbstractFuture&lt;?&gt; future, Listener update) {</a>
+<span class="sourceLineNo">1658</span><a id="line.1658">      synchronized (future) {</a>
+<span class="sourceLineNo">1659</span><a id="line.1659">        Listener old = future.listeners;</a>
+<span class="sourceLineNo">1660</span><a id="line.1660">        if (old != update) {</a>
+<span class="sourceLineNo">1661</span><a id="line.1661">          future.listeners = update;</a>
+<span class="sourceLineNo">1662</span><a id="line.1662">        }</a>
+<span class="sourceLineNo">1663</span><a id="line.1663">        return old;</a>
+<span class="sourceLineNo">1664</span><a id="line.1664">      }</a>
+<span class="sourceLineNo">1665</span><a id="line.1665">    }</a>
+<span class="sourceLineNo">1666</span><a id="line.1666"></a>
+<span class="sourceLineNo">1667</span><a id="line.1667">    @Override</a>
+<span class="sourceLineNo">1668</span><a id="line.1668">    Waiter gasWaiters(AbstractFuture&lt;?&gt; future, Waiter update) {</a>
+<span class="sourceLineNo">1669</span><a id="line.1669">      synchronized (future) {</a>
+<span class="sourceLineNo">1670</span><a id="line.1670">        Waiter old = future.waiters;</a>
+<span class="sourceLineNo">1671</span><a id="line.1671">        if (old != update) {</a>
+<span class="sourceLineNo">1672</span><a id="line.1672">          future.waiters = update;</a>
+<span class="sourceLineNo">1673</span><a id="line.1673">        }</a>
+<span class="sourceLineNo">1674</span><a id="line.1674">        return old;</a>
+<span class="sourceLineNo">1675</span><a id="line.1675">      }</a>
+<span class="sourceLineNo">1676</span><a id="line.1676">    }</a>
+<span class="sourceLineNo">1677</span><a id="line.1677"></a>
+<span class="sourceLineNo">1678</span><a id="line.1678">    @Override</a>
+<span class="sourceLineNo">1679</span><a id="line.1679">    boolean casValue(AbstractFuture&lt;?&gt; future, @Nullable Object expect, Object update) {</a>
+<span class="sourceLineNo">1680</span><a id="line.1680">      synchronized (future) {</a>
+<span class="sourceLineNo">1681</span><a id="line.1681">        if (future.value == expect) {</a>
+<span class="sourceLineNo">1682</span><a id="line.1682">          future.value = update;</a>
+<span class="sourceLineNo">1683</span><a id="line.1683">          return true;</a>
+<span class="sourceLineNo">1684</span><a id="line.1684">        }</a>
+<span class="sourceLineNo">1685</span><a id="line.1685">        return false;</a>
+<span class="sourceLineNo">1686</span><a id="line.1686">      }</a>
+<span class="sourceLineNo">1687</span><a id="line.1687">    }</a>
+<span class="sourceLineNo">1688</span><a id="line.1688">  }</a>
+<span class="sourceLineNo">1689</span><a id="line.1689"></a>
+<span class="sourceLineNo">1690</span><a id="line.1690">  private static CancellationException cancellationExceptionWithCause(</a>
+<span class="sourceLineNo">1691</span><a id="line.1691">      String message, @Nullable Throwable cause) {</a>
+<span class="sourceLineNo">1692</span><a id="line.1692">    CancellationException exception = new CancellationException(message);</a>
+<span class="sourceLineNo">1693</span><a id="line.1693">    exception.initCause(cause);</a>
+<span class="sourceLineNo">1694</span><a id="line.1694">    return exception;</a>
+<span class="sourceLineNo">1695</span><a id="line.1695">  }</a>
+<span class="sourceLineNo">1696</span><a id="line.1696">}</a>
 
 
 
diff --git a/releases/snapshot-jre/api/docs/type-search-index.zip b/releases/snapshot-jre/api/docs/type-search-index.zip
index 1a5872b99a36155ee08e6bb8f997eed266081934..8d6e976e31973c29bbd24a2b0104053660e5d408 100644
GIT binary patch
delta 30
kcmZ21wOEQbz?+#xgn@&DgQ2QSc_Z%$9%djt`38?S0BdIl(*OVf

delta 30
kcmZ21wOEQbz?+#xgn@&DgCT0M(nj7BJj_6P@(mtu0Bjit>i_@%