Release CacheLoader.asyncReload() in Guava 17.0.

-------------
Created by MOE: http://code.google.com/p/moe-java
MOE_MIGRATED_REVID=59050926

Author: cpovirk

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

@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2011 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.common.cache;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+
+import junit.framework.TestCase;
+
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Unit tests for {@link CacheLoader}.
+ *
+ * @author Charles Fry
+ */
+public class CacheLoaderTest extends TestCase {
+
+  private static class QueuingExecutor implements Executor {
+    private LinkedList<Runnable> tasks = Lists.newLinkedList();
+
+    @Override
+    public void execute(Runnable task) {
+      tasks.add(task);
+    }
+
+    private void runNext() {
+      tasks.pop().run();
+    }
+  }
+
+  public void testAsyncReload() throws Exception {
+    final AtomicInteger loadCount = new AtomicInteger();
+    final AtomicInteger reloadCount = new AtomicInteger();
+    final AtomicInteger loadAllCount = new AtomicInteger();
+
+    CacheLoader<Object, Object> baseLoader = new CacheLoader<Object, Object>() {
+      @Override
+      public Object load(Object key) {
+        loadCount.incrementAndGet();
+        return new Object();
+      }
+
+      @Override
+      public ListenableFuture<Object> reload(Object key, Object oldValue) {
+        reloadCount.incrementAndGet();
+        return Futures.immediateFuture(new Object());
+      }
+
+      @Override
+      public Map<Object, Object> loadAll(Iterable<? extends Object> keys) {
+        loadAllCount.incrementAndGet();
+        return ImmutableMap.of();
+      }
+    };
+
+    assertEquals(0, loadCount.get());
+    assertEquals(0, reloadCount.get());
+    assertEquals(0, loadAllCount.get());
+
+    baseLoader.load(new Object());
+    baseLoader.reload(new Object(), new Object());
+    baseLoader.loadAll(ImmutableList.of(new Object()));
+    assertEquals(1, loadCount.get());
+    assertEquals(1, reloadCount.get());
+    assertEquals(1, loadAllCount.get());
+
+    QueuingExecutor executor = new QueuingExecutor();
+    CacheLoader<Object, Object> asyncReloader =
+        CacheLoader.asyncReload(baseLoader, executor);
+
+    asyncReloader.load(new Object());
+    asyncReloader.reload(new Object(), new Object());
+    asyncReloader.loadAll(ImmutableList.of(new Object()));
+    assertEquals(2, loadCount.get());
+    assertEquals(1, reloadCount.get());
+    assertEquals(2, loadAllCount.get());
+
+    executor.runNext();
+    assertEquals(2, loadCount.get());
+    assertEquals(2, reloadCount.get());
+    assertEquals(2, loadAllCount.get());
+  }
+}

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

@@ -25,9 +25,12 @@
 import com.google.common.base.Supplier;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListenableFutureTask;
 
 import java.io.Serializable;
 import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executor;
 
 /**
  * Computes or retrieves values, based on a key, for use in populating a {@link LoadingCache}.
@@ -165,6 +168,46 @@ public static <V> CacheLoader<Object, V> from(Supplier<V> supplier) {
     return new SupplierToCacheLoader<V>(supplier);
   }
 
+  /**
+   * Returns a {@code CacheLoader} which wraps {@code loader}, executing calls to
+   * {@link CacheLoader#reload} using {@code executor}.
+   *
+   * <p>This method is useful only when {@code loader.reload} has a synchronous implementation,
+   * such as {@linkplain #reload the default implementation}.
+   *
+   * @since 17.0
+   */
+  @Beta
+  @GwtIncompatible("Executor + Futures")
+  public static <K, V> CacheLoader<K, V> asyncReload(final CacheLoader<K, V> loader,
+      final Executor executor) {
+    checkNotNull(loader);
+    checkNotNull(executor);
+    return new CacheLoader<K, V>() {
+      @Override
+      public V load(K key) throws Exception {
+        return loader.load(key);
+      }
+
+      @Override
+      public ListenableFuture<V> reload(final K key, final V oldValue) throws Exception {
+        ListenableFutureTask<V> task = ListenableFutureTask.create(new Callable<V>() {
+          @Override
+          public V call() throws Exception {
+            return loader.reload(key, oldValue).get();
+          }
+        });
+        executor.execute(task);
+        return task;
+      }
+
+      @Override
+      public Map<K, V> loadAll(Iterable<? extends K> keys) throws Exception {
+        return loader.loadAll(keys);
+      }
+    };
+  }
+
   private static final class SupplierToCacheLoader<V>
       extends CacheLoader<Object, V> implements Serializable {
     private final Supplier<V> computingSupplier;