refactor: make LocalCache not use synchronized to detect recursive loads (#6845)

guava-tests/test/com/google/common/cache/LocalCacheTest.java

@@ -58,6 +58,7 @@
 import com.google.common.testing.NullPointerTester;
 import com.google.common.testing.SerializableTester;
 import com.google.common.testing.TestLogHandler;
+import com.google.common.util.concurrent.UncheckedExecutionException;
 import java.io.Serializable;
 import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
@@ -2688,8 +2689,77 @@ public void testSerializationProxyManual() {
     assertEquals(localCacheTwo.ticker, localCacheThree.ticker);
   }
 
+  public void testLoadDifferentKeyInLoader() throws ExecutionException, InterruptedException {
+    LocalCache<String, String> cache = makeLocalCache(createCacheBuilder());
+    String key1 = "key1";
+    String key2 = "key2";
+
+    assertEquals(key2, cache.get(key1, new CacheLoader<String, String>() {
+      @Override
+      public String load(String key) throws Exception {
+        return cache.get(key2, identityLoader()); // loads a different key, should work
+      }
+    }));
+
+
+  }
+
+  public void testRecursiveLoad() throws InterruptedException {
+    LocalCache<String, String> cache = makeLocalCache(createCacheBuilder());
+    String key = "key";
+    CacheLoader<String, String> loader = new CacheLoader<String, String>() {
+      @Override
+      public String load(String key) throws Exception {
+        return cache.get(key, identityLoader()); // recursive load, this should fail
+      }
+    };
+    testLoadThrows(key, cache, loader);
+  }
+
+  public void testRecursiveLoadWithProxy() throws InterruptedException
+  {
+    String key = "key";
+    String otherKey = "otherKey";
+    LocalCache<String, String> cache = makeLocalCache(createCacheBuilder());
+    CacheLoader<String, String> loader = new CacheLoader<String, String>() {
+      @Override
+      public String load(String key) throws Exception {
+        return cache.get(key, identityLoader()); // recursive load (same as the initial one), this should fail
+      }
+    };
+    CacheLoader<String, String> proxyLoader = new CacheLoader<String, String>() {
+      @Override
+      public String load(String key) throws Exception {
+        return cache.get(otherKey, loader); // loads another key, is ok
+      }
+    };
+    testLoadThrows(key, cache, proxyLoader);
+  }
+
   // utility methods
 
+  private void testLoadThrows(String key, LocalCache<String, String> cache, CacheLoader<String,String> loader) throws InterruptedException
+  {
+    CountDownLatch doneSignal = new CountDownLatch(1);
+    Thread thread = new Thread(() -> {
+      try {
+        cache.get(key, loader);
+      } catch(UncheckedExecutionException | ExecutionException e) {
+        doneSignal.countDown();
+      }
+    });
+    thread.start();
+
+    boolean done = doneSignal.await(1, TimeUnit.SECONDS);
+    if (!done) {
+      StringBuilder builder = new StringBuilder();
+      for (StackTraceElement trace : thread.getStackTrace()) {
+        builder.append("\tat ").append(trace).append('\n');
+      }
+      fail(builder.toString());
+    }
+  }
+
   /**
    * Returns an iterable containing all combinations of maximumSize, expireAfterAccess/Write,
    * weakKeys and weak/softValues.

guava/src/com/google/common/cache/LocalCache.java

@@ -2184,12 +2184,7 @@ V lockedGetOrLoad(K key, int hash, CacheLoader<? super K, V> loader) throws Exec
 
       if (createNewEntry) {
         try {
-          // Synchronizes on the entry to allow failing fast when a recursive load is
-          // detected. This may be circumvented when an entry is copied, but will fail fast most
-          // of the time.
-          synchronized (e) {
-            return loadSync(key, hash, loadingValueReference, loader);
-          }
+          return loadSync(key, hash, loadingValueReference, loader);
         } finally {
           statsCounter.recordMisses(1);
         }
@@ -2205,7 +2200,14 @@ V waitForLoadingValue(ReferenceEntry<K, V> e, K key, ValueReference<K, V> valueR
         throw new AssertionError();
       }
 
-      checkState(!Thread.holdsLock(e), "Recursive load of: %s", key);
+      if (e.getValueReference() instanceof LoadingValueReference) {
+        // if the entry is still loading, we check whether the thread that
+        // is loading the entry is our current thread
+        // which would mean that we both load and wait for the entry
+        // in this case we fail fast instead of deadlocking
+        LoadingValueReference<K,V> le = (LoadingValueReference<K, V>)e.getValueReference();
+        checkState(le.getLoader() != Thread.currentThread(), "Recursive load of: %s", key);
+      }
       // don't consider expiration as we're concurrent with loading
       try {
         V value = valueReference.waitForValue();
@@ -3517,12 +3519,15 @@ static class LoadingValueReference<K, V> implements ValueReference<K, V> {
     final SettableFuture<V> futureValue = SettableFuture.create();
     final Stopwatch stopwatch = Stopwatch.createUnstarted();
 
+    final Thread loader;
+
     public LoadingValueReference() {
       this(null);
     }
 
     public LoadingValueReference(@CheckForNull ValueReference<K, V> oldValue) {
       this.oldValue = (oldValue == null) ? LocalCache.unset() : oldValue;
+      this.loader = Thread.currentThread();
     }
 
     @Override
@@ -3647,6 +3652,9 @@ public ValueReference<K, V> copyFor(
         ReferenceQueue<V> queue, @CheckForNull V value, ReferenceEntry<K, V> entry) {
       return this;
     }
+    Thread getLoader() {
+      return this.loader;
+    }
   }
 
   static class ComputingValueReference<K, V> extends LoadingValueReference<K, V> {