Make the guava-android copy of AbstractFuture try VarHandle when run under the JVM.

Under Android, I still don't have us even _try_ `VarHandle`:
- I'm not sure that using `VarHandle` is possible with our current internal Android build setup, as discussed in the internal commentary on cl/711733182.
- Using `VarHandle` there may at least somewhat more complex: My testing suggests that some versions of Android expose `VarHandle` to our reflective check but don't actually expose `MethodHandles.Lookup.findVarHandle`. Accordingly, sgjesse@ [recommends using a check on `SDK_INT`](https://issuetracker.google.com/issues/134377851#comment4) ([33](https://developer.android.com/reference/java/lang/invoke/MethodHandles.Lookup#findVarHandle(java.lang.Class%3C?%3E,%20java.lang.String,%20java.lang.Class%3C?%3E)) or higher) instead of reflection under Android. Since `guava-android` can be used under the JVM, too, we'd need to use a combination of the SDK check _and_ reflection. And we'd need to perform the `SDK_INT` check reflectively, as [we do in `TempFileCreator`](https://github.com/google/guava/blob/266ce0022a1c54244df1af0bde81116ed7703577/guava/src/com/google/common/io/TempFileCreator.java#L75) (which, hmm, I should clean up as obsolete one of these days...). (We could at least _reduce_ the amount of reflection we need if we were to depend on the Android SDK at build time, as discussed in b/403282918.)
- I have no idea whether `VarHandle` is faster or slower than `Unsafe` there (and I can't easily tell because of the build problems above).
- I'm not aware of efforts to remove `Unsafe` under Android.

This CL has two advantages for JVM users of `guava-android`:
- It eliminates a warning about usage of `Unsafe` under newer JDKs. Note that `AbstractFuture` _already_ has run correctly if access to `Unsafe` is outright disallowed (as with `-sun-misc-unsafe-memory-access=deny`): It detects this and falls back to an alternative implementation. However, if `Unsafe` is available but produces warnings, `guava-android` would use it, triggering those warnings. This CL makes Guava not even try to use it under newer JVMs because it now tries `VarHandle` first.
- `VarHandle` may be marginally faster than `Unsafe` under the JVM, as discussed in cl/711733182. (It also doesn't lead to VM crashes if you manage to pass `null` where you shouldn't, as I did back in b/397641020 :) But that's more something that's nice for us as Guava developers, not something that's nice for Guava _users_.)

This CL is probably the most _prominent_ part of [our migration of `guava-android` off `Unsafe`](#7742). It is debatable whether it is the most _important_, given that [at least one class, `Striped64`, does not seem to have a fallback at all if `Unsafe` is unavailable](#6806 (comment)). Still, this CL addresses the warning that most users are seeing, and it gives us some precedent for how to deal with `Striped64`.

Finally, it looks like our existing tests for `VarHandle` had [a mismatch between the context class loader and the class loader that we load `AbstractFutureTest` in](https://github.com/google/guava/blob/266ce0022a1c54244df1af0bde81116ed7703577/guava-tests/test/com/google/common/util/concurrent/AbstractFutureFallbackAtomicHelperTest.java#L105-L107)? That seems fairly bad. This CL fixes it, extracting a method to guard against future such mismatches. Out of an abundance of caution, I made a similar change in `AggregateFutureStateFallbackAtomicHelperTest`, even though there's not really an opportunity for a mismatch there, given that there's only one alternative class loader.

RELNOTES=`util.concurrent`: Changed the `guava-android` copy of `AbstractFuture` to try `VarHandle` before `Unsafe`, eliminating a warning under newer JDKs.
PiperOrigin-RevId: 743198569

Author: cpovirk

android/guava-tests/test/com/google/common/util/concurrent/AbstractFutureDefaultAtomicHelperTest.java

@@ -30,10 +30,18 @@
 @NullUnmarked
 public class AbstractFutureDefaultAtomicHelperTest extends TestCase {
   public void testUsingExpectedAtomicHelper() throws Exception {
-    assertThat(AbstractFutureState.atomicHelperTypeForTest()).isEqualTo("UnsafeAtomicHelper");
+    if (isJava8() || isAndroid()) {
+      assertThat(AbstractFutureState.atomicHelperTypeForTest()).isEqualTo("UnsafeAtomicHelper");
+    } else {
+      assertThat(AbstractFutureState.atomicHelperTypeForTest()).isEqualTo("VarHandleAtomicHelper");
+    }
   }
 
   private static boolean isJava8() {
     return JAVA_SPECIFICATION_VERSION.value().equals("1.8");
   }
+
+  private static boolean isAndroid() {
+    return System.getProperty("java.runtime.name", "").contains("Android");
+  }
 }

android/guava-tests/test/com/google/common/util/concurrent/AbstractFutureFallbackAtomicHelperTest.java

@@ -48,19 +48,30 @@ public class AbstractFutureFallbackAtomicHelperTest extends TestCase {
   // execution significantly)
 
   /**
-   * This classloader disallows {@link sun.misc.Unsafe}, which will prevent us from selecting our
-   * preferred strategy {@code UnsafeAtomicHelper}.
+   * This classloader disallows {@link java.lang.invoke.VarHandle}, which will prevent us from
+   * selecting the {@code VarHandleAtomicHelper} strategy.
    */
-  private static final ClassLoader NO_UNSAFE = getClassLoader(ImmutableSet.of("sun.misc.Unsafe"));
+  private static final ClassLoader NO_VAR_HANDLE =
+      getClassLoader(ImmutableSet.of("java.lang.invoke.VarHandle"));
 
   /**
-   * This classloader disallows {@link sun.misc.Unsafe} and {@link AtomicReferenceFieldUpdater},
-   * which will prevent us from selecting our {@code AtomicReferenceFieldUpdaterAtomicHelper}
-   * strategy.
+   * This classloader disallows {@link java.lang.invoke.VarHandle} and {@link sun.misc.Unsafe},
+   * which will prevent us from selecting the {@code UnsafeAtomicHelper} strategy.
+   */
+  private static final ClassLoader NO_UNSAFE =
+      getClassLoader(ImmutableSet.of("java.lang.invoke.VarHandle", "sun.misc.Unsafe"));
+
+  /**
+   * This classloader disallows {@link java.lang.invoke.VarHandle}, {@link sun.misc.Unsafe} and
+   * {@link AtomicReferenceFieldUpdater}, which will prevent us from selecting the {@code
+   * AtomicReferenceFieldUpdaterAtomicHelper} strategy.
    */
   private static final ClassLoader NO_ATOMIC_REFERENCE_FIELD_UPDATER =
       getClassLoader(
-          ImmutableSet.of("sun.misc.Unsafe", AtomicReferenceFieldUpdater.class.getName()));
+          ImmutableSet.of(
+              "java.lang.invoke.VarHandle",
+              "sun.misc.Unsafe",
+              AtomicReferenceFieldUpdater.class.getName()));
 
   public static TestSuite suite() {
     // we create a test suite containing a test for every AbstractFutureTest test method and we
@@ -79,34 +90,46 @@ public static TestSuite suite() {
   @Override
   public void runTest() throws Exception {
     // First ensure that our classloaders are initializing the correct helper versions
-    checkHelperVersion(getClass().getClassLoader(), "UnsafeAtomicHelper");
+    if (isJava8() || isAndroid()) {
+      checkHelperVersion(getClass().getClassLoader(), "UnsafeAtomicHelper");
+    } else {
+      checkHelperVersion(getClass().getClassLoader(), "VarHandleAtomicHelper");
+    }
+    checkHelperVersion(NO_VAR_HANDLE, "UnsafeAtomicHelper");
     checkHelperVersion(NO_UNSAFE, "AtomicReferenceFieldUpdaterAtomicHelper");
     checkHelperVersion(NO_ATOMIC_REFERENCE_FIELD_UPDATER, "SynchronizedHelper");
 
-    // Run the corresponding AbstractFutureTest test method in a new classloader that disallows
-    // certain core jdk classes.
-    ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
-    Thread.currentThread().setContextClassLoader(NO_UNSAFE);
-    try {
-      runTestMethod(NO_UNSAFE);
-    } finally {
-      Thread.currentThread().setContextClassLoader(oldClassLoader);
+    /*
+     * Under Java 8 or Android, there is no need to test the no-VarHandle case here: It's already
+     * tested by the main AbstractFutureTest, which uses the default AtomicHelper, which we verified
+     * above to be UnsafeAtomicHelper.
+     */
+    if (!isJava8() && !isAndroid()) {
+      runTestMethod(NO_VAR_HANDLE);
     }
 
-    Thread.currentThread().setContextClassLoader(NO_ATOMIC_REFERENCE_FIELD_UPDATER);
+    runTestMethod(NO_UNSAFE);
+
+    runTestMethod(NO_ATOMIC_REFERENCE_FIELD_UPDATER);
+    // TODO(lukes): assert that the logs are full of errors
+  }
+
+  /**
+   * Runs the corresponding {@link AbstractFutureTest} test method in a new classloader that
+   * disallows certain core JDK classes.
+   */
+  private void runTestMethod(ClassLoader classLoader) throws Exception {
+    ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
+
+    Thread.currentThread().setContextClassLoader(classLoader);
     try {
-      runTestMethod(NO_ATOMIC_REFERENCE_FIELD_UPDATER);
-      // TODO(lukes): assert that the logs are full of errors
+      Class<?> test = classLoader.loadClass(AbstractFutureTest.class.getName());
+      test.getMethod(getName()).invoke(test.getDeclaredConstructor().newInstance());
     } finally {
       Thread.currentThread().setContextClassLoader(oldClassLoader);
     }
   }
 
-  private void runTestMethod(ClassLoader classLoader) throws Exception {
-    Class<?> test = classLoader.loadClass(AbstractFutureTest.class.getName());
-    test.getMethod(getName()).invoke(test.getDeclaredConstructor().newInstance());
-  }
-
   private void checkHelperVersion(ClassLoader classLoader, String expectedHelperClassName)
       throws Exception {
     // Make sure we are actually running with the expected helper implementation
@@ -141,4 +164,8 @@ public Class<?> loadClass(String name) throws ClassNotFoundException {
   private static boolean isJava8() {
     return JAVA_SPECIFICATION_VERSION.value().equals("1.8");
   }
+
+  private static boolean isAndroid() {
+    return System.getProperty("java.runtime.name", "").contains("Android");
+  }
 }

android/guava-tests/test/com/google/common/util/concurrent/AggregateFutureStateFallbackAtomicHelperTest.java

@@ -50,8 +50,9 @@
 public class AggregateFutureStateFallbackAtomicHelperTest extends TestCase {
 
   /**
-   * This classloader disallows AtomicReferenceFieldUpdater and AtomicIntegerFieldUpdate which will
-   * prevent us from selecting our {@code SafeAtomicHelper} strategy.
+   * This classloader disallows {@code AtomicReferenceFieldUpdater} and {@code
+   * AtomicIntegerFieldUpdater}, which will prevent us from selecting the {@code SafeAtomicHelper}
+   * strategy.
    *
    * <p>Stashing this in a static field avoids loading it over and over again and speeds up test
    * execution significantly.
@@ -89,26 +90,28 @@ public void runTest() throws Exception {
     checkHelperVersion(getClass().getClassLoader(), "SafeAtomicHelper");
     checkHelperVersion(NO_ATOMIC_FIELD_UPDATER, "SynchronizedAtomicHelper");
 
-    // Run the corresponding FuturesTest test method in a new classloader that disallows
-    // certain core jdk classes.
+    runTestMethod(NO_ATOMIC_FIELD_UPDATER);
+    // TODO(lukes): assert that the logs are full of errors
+  }
+
+  /**
+   * Runs the corresponding {@link FuturesTest} test method in a new classloader that disallows
+   * certain core JDK classes.
+   */
+  private void runTestMethod(ClassLoader classLoader) throws Exception {
     ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
-    Thread.currentThread().setContextClassLoader(NO_ATOMIC_FIELD_UPDATER);
+    Thread.currentThread().setContextClassLoader(classLoader);
     try {
-      runTestMethod(NO_ATOMIC_FIELD_UPDATER);
-      // TODO(lukes): assert that the logs are full of errors
+      Class<?> test = classLoader.loadClass(FuturesTest.class.getName());
+      Object testInstance = test.getDeclaredConstructor().newInstance();
+      test.getMethod("setUp").invoke(testInstance);
+      test.getMethod(getName()).invoke(testInstance);
+      test.getMethod("tearDown").invoke(testInstance);
     } finally {
       Thread.currentThread().setContextClassLoader(oldClassLoader);
     }
   }
 
-  private void runTestMethod(ClassLoader classLoader) throws Exception {
-    Class<?> test = classLoader.loadClass(FuturesTest.class.getName());
-    Object testInstance = test.getDeclaredConstructor().newInstance();
-    test.getMethod("setUp").invoke(testInstance);
-    test.getMethod(getName()).invoke(testInstance);
-    test.getMethod("tearDown").invoke(testInstance);
-  }
-
   private void checkHelperVersion(ClassLoader classLoader, String expectedHelperClassName)
       throws Exception {
     // Make sure we are actually running with the expected helper implementation

android/guava/src/com/google/common/util/concurrent/AbstractFutureState.java

@@ -27,8 +27,11 @@
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.util.concurrent.AbstractFuture.Listener;
 import com.google.common.util.concurrent.internal.InternalFutureFailureAccess;
+import com.google.j2objc.annotations.J2ObjCIncompatible;
 import com.google.j2objc.annotations.ReflectionSupport;
 import com.google.j2objc.annotations.RetainedLocalRef;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
 import java.lang.reflect.Field;
 import java.security.PrivilegedActionException;
 import java.security.PrivilegedExceptionAction;
@@ -345,21 +348,24 @@ void unpark() {
     Throwable thrownUnsafeFailure = null;
     Throwable thrownAtomicReferenceFieldUpdaterFailure = null;
 
-    try {
-      helper = new UnsafeAtomicHelper();
-    } catch (Exception | Error unsafeFailure) { // sneaky checked exception
-      thrownUnsafeFailure = unsafeFailure;
-      // Catch absolutely everything and fall through to AtomicReferenceFieldUpdaterAtomicHelper.
+    helper = VarHandleAtomicHelperMaker.INSTANCE.tryMakeVarHandleAtomicHelper();
+    if (helper == null) {
       try {
-        helper = new AtomicReferenceFieldUpdaterAtomicHelper();
-      } catch (Exception // sneaky checked exception
-          | Error atomicReferenceFieldUpdaterFailure) {
-        // Some Android 5.0.x Samsung devices have bugs in JDK reflection APIs that cause
-        // getDeclaredField to throw a NoSuchFieldException when the field is definitely there.
-        // For these users fallback to a suboptimal implementation, based on synchronized. This
-        // will be a definite performance hit to those users.
-        thrownAtomicReferenceFieldUpdaterFailure = atomicReferenceFieldUpdaterFailure;
-        helper = new SynchronizedHelper();
+        helper = new UnsafeAtomicHelper();
+      } catch (Exception | Error unsafeFailure) { // sneaky checked exception
+        thrownUnsafeFailure = unsafeFailure;
+        // Catch absolutely everything and fall through to AtomicReferenceFieldUpdaterAtomicHelper.
+        try {
+          helper = new AtomicReferenceFieldUpdaterAtomicHelper();
+        } catch (Exception // sneaky checked exception
+            | Error atomicReferenceFieldUpdaterFailure) {
+          // Some Android 5.0.x Samsung devices have bugs in JDK reflection APIs that cause
+          // getDeclaredField to throw a NoSuchFieldException when the field is definitely there.
+          // For these users fallback to a suboptimal implementation, based on synchronized. This
+          // will be a definite performance hit to those users.
+          thrownAtomicReferenceFieldUpdaterFailure = atomicReferenceFieldUpdaterFailure;
+          helper = new SynchronizedHelper();
+        }
       }
     }
     ATOMIC_HELPER = helper;
@@ -496,6 +502,43 @@ static String atomicHelperTypeForTest() {
     return ATOMIC_HELPER.atomicHelperTypeForTest();
   }
 
+  private enum VarHandleAtomicHelperMaker {
+    INSTANCE {
+      /**
+       * Implementation used by non-J2ObjC environments (aside, of course, from those that have
+       * supersource for the entirety of {@link AbstractFutureState}).
+       */
+      @Override
+      @J2ObjCIncompatible
+      @Nullable AtomicHelper tryMakeVarHandleAtomicHelper() {
+        if (mightBeAndroid()) {
+          return null;
+        }
+        try {
+          /*
+           * We first use reflection to check whether VarHandle exists. If we instead just tried to
+           * load our class directly (which would trigger non-reflective loading of VarHandle) from
+           * within a `try` block, then an error might be thrown even before we enter the `try`
+           * block: https://github.com/google/truth/issues/333#issuecomment-765652454
+           *
+           * Also, it's nice that this approach should let us catch *only* ClassNotFoundException
+           * instead of having to catch more broadly (potentially even including, say, a
+           * StackOverflowError).
+           */
+          Class.forName("java.lang.invoke.VarHandle");
+        } catch (ClassNotFoundException beforeJava9) {
+          return null;
+        }
+        return new VarHandleAtomicHelper();
+      }
+    };
+
+    /** Implementation used by J2ObjC environments, overridden for other environments. */
+    @Nullable AtomicHelper tryMakeVarHandleAtomicHelper() {
+      return null;
+    }
+  }
+
   private abstract static class AtomicHelper {
     /** Non-volatile write of the thread to the {@link Waiter#thread} field. */
     abstract void putThread(Waiter waiter, Thread newValue);
@@ -524,6 +567,81 @@ abstract boolean casValue(
     abstract String atomicHelperTypeForTest();
   }
 
+  /** {@link AtomicHelper} based on {@link VarHandle}. */
+  @J2ObjCIncompatible
+  // We use this class only after confirming that VarHandle is available at runtime.
+  @SuppressWarnings({"Java8ApiChecker", "Java7ApiChecker", "AndroidJdkLibsChecker"})
+  @IgnoreJRERequirement
+  private static final class VarHandleAtomicHelper extends AtomicHelper {
+    static final VarHandle waiterThreadUpdater;
+    static final VarHandle waiterNextUpdater;
+    static final VarHandle waitersUpdater;
+    static final VarHandle listenersUpdater;
+    static final VarHandle valueUpdater;
+
+    static {
+      MethodHandles.Lookup lookup = MethodHandles.lookup();
+      try {
+        waiterThreadUpdater = lookup.findVarHandle(Waiter.class, "thread", Thread.class);
+        waiterNextUpdater = lookup.findVarHandle(Waiter.class, "next", Waiter.class);
+        waitersUpdater =
+            lookup.findVarHandle(AbstractFutureState.class, "waitersField", Waiter.class);
+        listenersUpdater =
+            lookup.findVarHandle(AbstractFutureState.class, "listenersField", Listener.class);
+        valueUpdater = lookup.findVarHandle(AbstractFutureState.class, "valueField", Object.class);
+      } catch (ReflectiveOperationException e) {
+        // Those fields exist.
+        throw newLinkageError(e);
+      }
+    }
+
+    @Override
+    void putThread(Waiter waiter, Thread newValue) {
+      waiterThreadUpdater.setRelease(waiter, newValue);
+    }
+
+    @Override
+    void putNext(Waiter waiter, @Nullable Waiter newValue) {
+      waiterNextUpdater.setRelease(waiter, newValue);
+    }
+
+    @Override
+    boolean casWaiters(
+        AbstractFutureState<?> future, @Nullable Waiter expect, @Nullable Waiter update) {
+      return waitersUpdater.compareAndSet(future, expect, update);
+    }
+
+    @Override
+    boolean casListeners(
+        AbstractFutureState<?> future, @Nullable Listener expect, Listener update) {
+      return listenersUpdater.compareAndSet(future, expect, update);
+    }
+
+    @Override
+    @Nullable Listener gasListeners(AbstractFutureState<?> future, Listener update) {
+      return (Listener) listenersUpdater.getAndSet(future, update);
+    }
+
+    @Override
+    @Nullable Waiter gasWaiters(AbstractFutureState<?> future, Waiter update) {
+      return (Waiter) waitersUpdater.getAndSet(future, update);
+    }
+
+    @Override
+    boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object update) {
+      return valueUpdater.compareAndSet(future, expect, update);
+    }
+
+    private static LinkageError newLinkageError(Throwable cause) {
+      return new LinkageError(cause.toString(), cause);
+    }
+
+    @Override
+    String atomicHelperTypeForTest() {
+      return "VarHandleAtomicHelper";
+    }
+  }
+
   /**
    * {@link AtomicHelper} based on {@link sun.misc.Unsafe}.
    *
@@ -777,4 +895,10 @@ String atomicHelperTypeForTest() {
       return "SynchronizedHelper";
     }
   }
+
+  private static boolean mightBeAndroid() {
+    String runtime = System.getProperty("java.runtime.name", "");
+    // I have no reason to believe that `null` is possible here, but let's make sure we don't crash:
+    return runtime == null || runtime.contains("Android");
+  }
 }

guava-tests/test/com/google/common/util/concurrent/AbstractFutureDefaultAtomicHelperTest.java

@@ -30,7 +30,7 @@
 @NullUnmarked
 public class AbstractFutureDefaultAtomicHelperTest extends TestCase {
   public void testUsingExpectedAtomicHelper() throws Exception {
-    if (isJava8()) {
+    if (isJava8() || isAndroid()) {
       assertThat(AbstractFutureState.atomicHelperTypeForTest()).isEqualTo("UnsafeAtomicHelper");
     } else {
       assertThat(AbstractFutureState.atomicHelperTypeForTest()).isEqualTo("VarHandleAtomicHelper");
@@ -40,4 +40,8 @@ public void testUsingExpectedAtomicHelper() throws Exception {
   private static boolean isJava8() {
     return JAVA_SPECIFICATION_VERSION.value().equals("1.8");
   }
+
+  private static boolean isAndroid() {
+    return System.getProperty("java.runtime.name", "").contains("Android");
+  }
 }