#5836

Committed 20 Oct 2026 07:25AM UTC coverage: 99.989% (-0.01%) from 100.0%

Build # #5836

Build Type

push

github

Committed by

ben-manes

Commit Message

join an in-flight refresh of an expired entry

A refresh of an expired or collected entry replaced any registration,
so while another refresh's loader was still running, each caller
replaced the last and loaded again: 8 refreshes made 8 loads and kept
only the last value. Such a refresh now joins the placeholder and
takes the linearization point of the refresh it joined, so a reload
whose entry expired during it is discarded at commit as it is when the
entry expires after the join. This also rejects a loader refreshing its
own key without a separate owner check.

Coverage Stats

4872 of 4882 branches covered (99.8%)

2 of 2 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

9348 of 9349 relevant lines covered (99.99%)

1.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.88

/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalAsyncCache.java

/*
 * Copyright 2018 Ben Manes. All Rights Reserved.
 *
 * 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.github.benmanes.caffeine.cache;

import static com.github.benmanes.caffeine.cache.Caffeine.calculateHashMapCapacity;
import static com.github.benmanes.caffeine.cache.Caffeine.requireArgument;
import static com.github.benmanes.caffeine.cache.Caffeine.requireState;
import static com.github.benmanes.caffeine.cache.Caffeine.toUnchecked;
import static com.github.benmanes.caffeine.cache.LocalCache.castNonNull;
import static java.util.Locale.US;
import static java.util.Objects.requireNonNull;

import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.lang.System.Logger;
import java.lang.System.Logger.Level;
import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Set;
import java.util.Spliterator;
import java.util.concurrent.CancellationException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeoutException;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

import org.jspecify.annotations.Nullable;

import com.github.benmanes.caffeine.cache.LocalAsyncCache.AsyncBulkCompleter.NullMapCompletionException;
import com.github.benmanes.caffeine.cache.stats.CacheStats;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.Var;

/**
 * This class provides a skeletal implementation of the {@link AsyncCache} interface to minimize the
 * effort required to implement a {@link LocalCache}.
 *
 * @author ben.manes@gmail.com (Ben Manes)
 */
interface LocalAsyncCache<K, V> extends AsyncCache<K, V> {
  Logger logger = System.getLogger(LocalAsyncCache.class.getName());

  /** Returns the backing {@link LocalCache} data store. */
  LocalCache<K, CompletableFuture<V>> cache();

  /** Returns the policy supported by this implementation and its configuration. */
  Policy<K, V> policy();

  @Override
  default @Nullable CompletableFuture<V> getIfPresent(K key) {
    return cache().getIfPresent(key, /* recordStats= */ true);
  }

  @Override
  default CompletableFuture<V> get(K key, Function<? super K, ? extends V> mappingFunction) {
    requireNonNull(mappingFunction);
    return get(key, (k, executor) -> CompletableFuture.supplyAsync(
        () -> mappingFunction.apply(k), executor));
  }

  @Override
  default CompletableFuture<V> get(K key, BiFunction<? super K, ? super Executor,
      ? extends CompletableFuture<? extends V>> mappingFunction) {
    requireNonNull(mappingFunction);
    return get(key, mappingFunction, /* recordStats= */ true);
  }

  default CompletableFuture<V> get(K key, BiFunction<? super K, ? super Executor,
      ? extends CompletableFuture<? extends V>> mappingFunction, boolean recordStats) {
    CompletableFuture<V> present = cache().getIfPresent(key, /* recordStats= */ false);
    if (present != null) {
      if (recordStats) {
        cache().statsCounter().recordHits(1);
      }
      return present;
    }

    var deferred = new boolean[1];
    long startTime = cache().statsTicker().read();
    @SuppressWarnings({"rawtypes", "unchecked"})
    @Nullable CompletableFuture<? extends V>[] result = new CompletableFuture[1];
    CompletableFuture<V> future = cache().computeIfAbsent(key, k -> {
      @SuppressWarnings("unchecked")
      var castedResult = (CompletableFuture<V>) mappingFunction.apply(key, cache().executor());
      deferred[0] = !Async.isReady(castedResult);
      result[0] = castedResult;
      return requireNonNull(castedResult);
    }, recordStats, /* recordLoad= */ false);
    if (result[0] != null) {
      handleCompletion(key, result[0], startTime, deferred[0], /* computed= */ true);
    }
    return requireNonNull(future);
  }

  @Override
  default CompletableFuture<Map<K, V>> getAll(Iterable<? extends K> keys,
      Function<? super Set<? extends K>, ? extends Map<? extends K, ? extends V>> mappingFunction) {
    requireNonNull(mappingFunction);
    return getAll(keys, (keysToLoad, executor) ->
        CompletableFuture.supplyAsync(() -> mappingFunction.apply(keysToLoad), executor));
  }

  @Override
  @SuppressWarnings("FutureReturnValueIgnored")
  default CompletableFuture<Map<K, V>> getAll(Iterable<? extends K> keys,
      BiFunction<? super Set<? extends K>, ? super Executor,
          ? extends CompletableFuture<? extends Map<? extends K, ? extends V>>> mappingFunction) {
    requireNonNull(mappingFunction);
    requireNonNull(keys);

    int initialCapacity = calculateHashMapCapacity(keys);
    var futures = new LinkedHashMap<K, @Nullable CompletableFuture<@Nullable V>>(initialCapacity);
    for (K key : keys) {
      futures.put(requireNonNull(key), null);
    }

    var proxies = new LinkedHashMap<K, CompletableFuture<V>>(initialCapacity);
    try {
      for (var entry : futures.entrySet()) {
        K key = entry.getKey();
        @Var CompletableFuture<V> future = cache().getIfPresent(key, /* recordStats= */ false);
        if (future == null) {
          var proxy = new CompletableFuture<V>();
          future = cache().putIfAbsent(key, proxy);
          if (future == null) {
            future = proxy;
            proxies.put(key, proxy);
          }
        }
        @SuppressWarnings("NullAway")
        CompletableFuture<@Nullable V> castedFuture = future;
        entry.setValue(castedFuture);
      }
    } catch (Throwable t) {
      for (var entry : proxies.entrySet()) {
        cache().remove(entry.getKey(), entry.getValue());
        entry.getValue().obtrudeException(t);
      }
      throw t;
    }
    cache().statsCounter().recordMisses(proxies.size());
    cache().statsCounter().recordHits(futures.size() - proxies.size());

    @SuppressWarnings("NullAway")
    Map<K, CompletableFuture<@Nullable V>> results = futures;
    if (proxies.isEmpty()) {
      return composeResult(results);
    }

    @SuppressWarnings("NullAway")
    Map<K, CompletableFuture<@Nullable V>> pending = proxies;
    var completer = new AsyncBulkCompleter<>(cache(), pending);
    try {
      var loader = mappingFunction.apply(
          Collections.unmodifiableSet(proxies.keySet()), cache().executor());
      return loader.handle(completer).thenCompose(ignored -> composeResult(results));
    } catch (Throwable t) {
      throw completer.error(t);
    }
  }

  /**
   * Returns a future that waits for all of the dependent futures to complete and returns the
   * combined mapping if successful. If any future fails then it is automatically removed from
   * the cache if still present.
   */
  static <K, V> CompletableFuture<Map<K, V>> composeResult(
      Map<K, CompletableFuture<@Nullable V>> futures) {
    if (futures.isEmpty()) {
      @SuppressWarnings({"ImmutableMapOf", "RedundantUnmodifiable"})
      Map<K, V> emptyMap = Collections.unmodifiableMap(Collections.emptyMap());
      return CompletableFuture.completedFuture(emptyMap);
    }
    @SuppressWarnings("rawtypes")
    CompletableFuture<?>[] array = futures.values().toArray(new CompletableFuture[0]);
    return CompletableFuture.allOf(array).thenApply(ignored -> {
      var result = new LinkedHashMap<K, V>(calculateHashMapCapacity(futures.size()));
      futures.forEach((key, future) -> {
        V value = future.getNow(null);
        if (value != null) {
          result.put(key, value);
        }
      });
      return Collections.unmodifiableMap(result);
    });
  }

  @Override
  @SuppressWarnings("FutureReturnValueIgnored")
  default void put(K key, CompletableFuture<? extends @Nullable V> valueFuture) {
    long startTime = cache().statsTicker().read();

    @SuppressWarnings("unchecked")
    var castedFuture = (CompletableFuture<V>) valueFuture;
    boolean deferred = !Async.isReady(castedFuture);
    CompletableFuture<V> prior = cache().put(key, castedFuture);
    if (prior != castedFuture) {
      handleCompletion(key, valueFuture, startTime, deferred, /* computed= */ false);
    } else if (deferred) {
      handleRewrite(key, castedFuture);
    }
  }

  /**
   * Registers the callback that completes the insertion of the value once it is available.
   *
   * @param key the key that the future was inserted with
   * @param valueFuture the inserted future
   * @param startTime the time when the load started, in nanoseconds
   * @param deferred whether the insertion deferred the entry's weight and expiration to the
   *        completion, which it does when the value was not yet available to evaluate them
   * @param computed whether the caller computed the value, which a write does not
   */
  @SuppressWarnings({"FutureReturnValueIgnored", "ResultOfMethodCallIgnored"})
  default void handleCompletion(K key, CompletableFuture<? extends @Nullable V> valueFuture,
      long startTime, boolean deferred, boolean computed) {
    boolean recordLoad = computed || deferred;
    valueFuture.whenComplete((value, error) -> {
      long loadTime = cache().statsTicker().read() - startTime;
      if (value == null) {
        if ((error != null) && !(error instanceof CancellationException)
            && !(error instanceof TimeoutException)) {
          logger.log(Level.WARNING, "Exception thrown during asynchronous load", error);
        }
        if (recordLoad) {
          cache().statsCounter().recordLoadFailure(loadTime);
        }
        cache().remove(key, valueFuture);
      } else if (!Async.isReady(valueFuture)) {
        logger.log(Level.ERROR, String.format(US, "An invalid state was detected, occurring when "
            + "the future's dependent action has completed successfully with a value, but the "
            + "future remains either in-flight or in a failed completion state. This may occur "
            + "when using a custom future that does not abide by the CompletableFuture contract "
            + "(key: %s, key type: %s, value type: %s, future: %s, cache type: %s).",
            key, key.getClass().getName(), value.getClass().getName(), valueFuture,
            cache().getClass().getSimpleName()), new IllegalStateException());
        if (recordLoad) {
          cache().statsCounter().recordLoadFailure(loadTime);
        }
        cache().remove(key, valueFuture);
      } else {
        @SuppressWarnings("unchecked")
        var castedFuture = (CompletableFuture<V>) valueFuture;

        try {
          if (deferred) {
            // update the weight and expiration timestamps
            cache().replace(key, castedFuture, castedFuture,
                /* shouldDiscardRefresh= */ false, /* quietly= */ true);
          }
          if (recordLoad) {
            cache().statsCounter().recordLoadSuccess(loadTime);
          }
        } catch (Throwable t) {
          logger.log(Level.WARNING, "Exception thrown during asynchronous load", t);
          cache().statsCounter().recordLoadFailure(loadTime);
          cache().remove(key, valueFuture);
        }
      }
    });
  }

  /**
   * Finalizes a future that was written over itself if it completed during the write. The write
   * weighs the value before it locks the entry, so it may have overwritten the weight that the
   * insertion's callback finalized and a future still in-flight is left to that callback.
   *
   * @param key the key that the future was written with
   * @param valueFuture the future that replaced itself
   */
  @SuppressWarnings("ResultOfMethodCallIgnored")
  default void handleRewrite(K key, CompletableFuture<V> valueFuture) {
    if (!Async.isReady(valueFuture)) {
      return;
    }
    try {
      cache().replace(key, valueFuture, valueFuture,
          /* shouldDiscardRefresh= */ false, /* quietly= */ true);
    } catch (Throwable t) {
      logger.log(Level.WARNING, "Exception thrown during asynchronous load", t);
      cache().remove(key, valueFuture);
    }
  }

  /** A function executed asynchronously after a bulk load completes. */
  final class AsyncBulkCompleter<K, V> implements BiFunction<@Nullable Map<? extends K, ? extends V>,
      @Nullable Throwable, @Nullable Map<? extends K, ? extends V>> {
    @SuppressWarnings("ImmutableMemberCollection")
    private final Map<K, CompletableFuture<@Nullable V>> proxies;
    private final LocalCache<K, CompletableFuture<V>> cache;
    private final long startTime;

    AsyncBulkCompleter(LocalCache<K, CompletableFuture<V>> cache,
        Map<K, CompletableFuture<@Nullable V>> proxies) {
      this.startTime = cache.statsTicker().read();
      this.proxies = proxies;
      this.cache = cache;
    }

    @Override
    @CanIgnoreReturnValue
    public @Nullable Map<? extends K, ? extends V> apply(
        @Nullable Map<? extends K, ? extends V> result, @Nullable Throwable error) {
      long loadTime = cache.statsTicker().read() - startTime;
      var failure = handleResponse(result, error);

      if (failure == null) {
        if (requireNonNull(result).isEmpty()) {
          cache.statsCounter().recordLoadFailure(loadTime);
        } else {
          cache.statsCounter().recordLoadSuccess(loadTime);
        }
        return result;
      }

      cache.statsCounter().recordLoadFailure(loadTime);
      throw toUnchecked(failure);
    }

    public RuntimeException error(Throwable error) {
      long loadTime = cache.statsTicker().read() - startTime;
      var failure = requireNonNull(handleResponse(/* result= */ null, error));
      cache.statsCounter().recordLoadFailure(loadTime);
      return toUnchecked(failure);
    }

    private @Nullable Throwable handleResponse(
        @Nullable Map<? extends K, ? extends V> result, @Nullable Throwable error) {
      if (result == null) {
        var failure = (error == null) ? new NullMapCompletionException() : error;
        failProxies(failure);
        return failure;
      }

      Map<K, V> snapshot;
      try {
        snapshot = snapshotOf(result);
      } catch (Throwable t) {
        failProxies(t);
        return t;
      }

      var failure = fillProxies(snapshot);
      return addNewEntries(snapshot, failure);
    }

    /** Returns a copy of the computed result, rejecting a null or duplicate mapping. */
    private static <K, V> Map<K, V> snapshotOf(Map<? extends K, ? extends V> result) {
      var snapshot = new LinkedHashMap<K, V>(calculateHashMapCapacity(result.size()));
      for (var entry : result.entrySet()) {
        K key = requireNonNull(entry.getKey());
        V value = requireNonNull(entry.getValue());
        requireArgument(snapshot.put(key, value) == null, "duplicate key: %s", key);
      }
      return snapshot;
    }

    /** Removes and exceptionally completes every requested proxy. */
    private void failProxies(Throwable failure) {
      for (var entry : proxies.entrySet()) {
        cache.remove(entry.getKey(), entry.getValue());
        entry.getValue().obtrudeException(failure);
      }
      if (!(failure instanceof CancellationException) && !(failure instanceof TimeoutException)) {
        logger.log(Level.WARNING, "Exception thrown during asynchronous load", failure);
      }
    }

    /** Populates the proxies with the computed result. */
    private @Nullable Throwable fillProxies(Map<? extends K, ? extends V> result) {
      @Var Throwable error = null;
      for (var entry : proxies.entrySet()) {
        var key = entry.getKey();
        var value = result.get(key);
        var future = entry.getValue();
        future.obtrudeValue(value);

        if (value == null) {
          cache.remove(key, future);
        } else {
          @SuppressWarnings("NullAway")
          CompletableFuture<V> castedFuture = future;

          try {
            // update the weight and expiration timestamps; a same-instance finalization is not a
            // mutation, so an in-flight refresh is preserved (mirrors handleCompletion)
            cache.replace(key, castedFuture, castedFuture,
                /* shouldDiscardRefresh= */ false, /* quietly= */ true);
          } catch (Throwable t) {
            logger.log(Level.WARNING, "Exception thrown during asynchronous load", t);
            cache.remove(key, future);
            if (error == null) {
              error = t;
            } else if (error != t) {
              error.addSuppressed(t);
            }
          }
        }
      }
      return error;
    }

    /** Adds to the cache any extra entries computed that were not requested. */
    private @Nullable Throwable addNewEntries(
        Map<? extends K, ? extends V> result, @Nullable Throwable failure) {
      @Var Throwable error = failure;
      for (var entry : result.entrySet()) {
        var key = entry.getKey();
        if (!proxies.containsKey(key)) {
          V value = entry.getValue();
          try {
            cache.put(key, CompletableFuture.completedFuture(value));
          } catch (Throwable t) {
            logger.log(Level.WARNING, "Exception thrown during asynchronous load", t);
            if (error == null) {
              error = t;
            } else if (error != t) {
              error.addSuppressed(t);
            }
          }
        }
      }
      return error;
    }

    static final class NullMapCompletionException extends CompletionException {
      private static final long serialVersionUID = 1L;
    }
  }

  /* --------------- Asynchronous view --------------- */
  final class AsyncAsMapView<K, V> implements ConcurrentMap<K, CompletableFuture<V>> {
    private @Nullable Set<Entry<K, CompletableFuture<V>>> entrySet;
    private final LocalAsyncCache<K, V> asyncCache;

    AsyncAsMapView(LocalAsyncCache<K, V> asyncCache) {
      this.asyncCache = requireNonNull(asyncCache);
    }
    @Override public boolean isEmpty() {
      return asyncCache.cache().isEmpty();
    }
    @Override public int size() {
      return asyncCache.cache().size();
    }
    @Override public void clear() {
      asyncCache.cache().clear();
    }
    @Override public boolean containsKey(@Nullable Object key) {
      return asyncCache.cache().containsKey(key);
    }
    @SuppressWarnings("CollectionUndefinedEquality")
    @Override public boolean containsValue(@Nullable Object value) {
      return asyncCache.cache().containsValue(value);
    }
    @Override public @Nullable CompletableFuture<V> get(@Nullable Object key) {
      return asyncCache.cache().get(key);
    }
    @Override public @Nullable CompletableFuture<V> putIfAbsent(K key, CompletableFuture<V> value) {
      boolean deferred = !Async.isReady(value);
      CompletableFuture<V> prior = asyncCache.cache().putIfAbsent(key, value);
      if (prior == null) {
        long startTime = asyncCache.cache().statsTicker().read();
        asyncCache.handleCompletion(key, value, startTime, deferred, /* computed= */ false);
      }
      return prior;
    }
    @Override public @Nullable CompletableFuture<V> put(K key, CompletableFuture<V> value) {
      boolean deferred = !Async.isReady(value);
      CompletableFuture<V> prior = asyncCache.cache().put(key, value);
      if (prior != value) {
        long startTime = asyncCache.cache().statsTicker().read();
        asyncCache.handleCompletion(key, value, startTime, deferred, /* computed= */ false);
      } else if (deferred) {
        asyncCache.handleRewrite(key, value);
      }
      return prior;
    }
    @SuppressWarnings({"FutureReturnValueIgnored", "ResultOfMethodCallIgnored"})
    @Override public void putAll(Map<? extends K, ? extends CompletableFuture<V>> map) {
      map.forEach(this::put);
    }
    @Override public @Nullable CompletableFuture<V> replace(K key, CompletableFuture<V> value) {
      boolean deferred = !Async.isReady(value);
      CompletableFuture<V> prior = asyncCache.cache().replace(key, value);
      if ((prior != null) && (prior != value)) {
        long startTime = asyncCache.cache().statsTicker().read();
        asyncCache.handleCompletion(key, value, startTime, deferred, /* computed= */ false);
      } else if ((prior != null) && deferred) {
        asyncCache.handleRewrite(key, value);
      }
      return prior;
    }
    @Override
    public boolean replace(K key, CompletableFuture<V> oldValue, CompletableFuture<V> newValue) {
      boolean deferred = !Async.isReady(newValue);
      boolean replaced = asyncCache.cache().replace(key, oldValue, newValue);
      if (replaced && (newValue != oldValue)) {
        long startTime = asyncCache.cache().statsTicker().read();
        asyncCache.handleCompletion(key, newValue, startTime, deferred, /* computed= */ false);
      } else if (replaced && deferred) {
        asyncCache.handleRewrite(key, newValue);
      }
      return replaced;
    }
    @SuppressWarnings({"CheckReturnValue", "FutureReturnValueIgnored"})
    @Override public void replaceAll(BiFunction<? super K, ? super CompletableFuture<V>,
        ? extends CompletableFuture<V>> function) {
      requireNonNull(function);
      for (K key : keySet()) {
        computeIfPresent(key, (k, oldValue) -> requireNonNull(function.apply(k, oldValue)));
      }
    }
    @Override public @Nullable CompletableFuture<V> remove(@Nullable Object key) {
      return asyncCache.cache().remove(key);
    }
    @Override public boolean remove(@Nullable Object key, @Nullable Object value) {
      return asyncCache.cache().remove(key, value);
    }
    @Override public CompletableFuture<V> computeIfAbsent(K key,
        Function<? super K, ? extends @Nullable CompletableFuture<V>> mappingFunction) {
      requireNonNull(mappingFunction);
      var deferred = new boolean[1];
      @SuppressWarnings({"rawtypes", "unchecked"})
      @Nullable CompletableFuture<V>[] result = new CompletableFuture[1];
      long startTime = asyncCache.cache().statsTicker().read();
      Function<K, @Nullable CompletableFuture<V>> function = k -> {
        result[0] = mappingFunction.apply(k);
        deferred[0] = !Async.isReady(result[0]);
        return result[0];
      };
      CompletableFuture<V> future = asyncCache.cache().computeIfAbsent(
          key, function, /* recordStats= */ true, /* recordLoad= */ false);
      if (result[0] != null) {
        asyncCache.handleCompletion(key, result[0], startTime, deferred[0], /* computed= */ true);
      }
      return castNonNull(future);
    }
    @Override public @Nullable CompletableFuture<V> computeIfPresent(K key,
        BiFunction<? super K, ? super CompletableFuture<V>,
            ? extends @Nullable CompletableFuture<V>> remappingFunction) {
      requireNonNull(remappingFunction);
      return compute(key, (k, oldValue) ->
          (oldValue == null) ? null : remappingFunction.apply(k, oldValue));
    }
    @Override public @Nullable CompletableFuture<V> compute(K key,
        BiFunction<? super K, ? super @Nullable CompletableFuture<V>,
            ? extends @Nullable CompletableFuture<V>> remappingFunction) {
      requireNonNull(remappingFunction);

      var deferred = new boolean[1];
      @SuppressWarnings({"rawtypes", "unchecked"})
      @Nullable CompletableFuture<V>[] prior = new CompletableFuture[1];
      long startTime = asyncCache.cache().statsTicker().read();
      CompletableFuture<V> result = asyncCache.cache().compute(
          key, (K k, @Nullable CompletableFuture<V> oldValue) -> {
            var computed = remappingFunction.apply(k, oldValue);
            deferred[0] = !Async.isReady(computed);
            prior[0] = oldValue;
            return computed;
          }, asyncCache.cache().expiry(), /* recordLoad= */ false);

      if ((result != null) && (result != prior[0])) {
        asyncCache.handleCompletion(key, result, startTime, deferred[0], /* computed= */ true);
      }
      return result;
    }
    @Override public @Nullable CompletableFuture<V> merge(K key, CompletableFuture<V> value,
        BiFunction<? super CompletableFuture<V>, ? super CompletableFuture<V>,
            ? extends @Nullable CompletableFuture<V>> remappingFunction) {
      requireNonNull(value);
      requireNonNull(remappingFunction);
      return compute(key, (k, oldValue) ->
          (oldValue == null) ? value : remappingFunction.apply(oldValue, value));
    }
    @Override public void forEach(BiConsumer<? super K, ? super CompletableFuture<V>> action) {
      asyncCache.cache().forEach(action);
    }
    @Override public Set<K> keySet() {
      return asyncCache.cache().keySet();
    }
    @Override public Collection<CompletableFuture<V>> values() {
      return asyncCache.cache().values();
    }
    @Override public Set<Entry<K, CompletableFuture<V>>> entrySet() {
      var es = entrySet;
      return (es == null) ? (entrySet = new AsyncEntrySet()) : es;
    }
    @SuppressWarnings("EqualsWhichDoesntCheckParameterClass")
    @Override public boolean equals(@Nullable Object o) {
      return (o == this) || asyncCache.cache().equals(o);
    }
    @Override public int hashCode() {
      return asyncCache.cache().hashCode();
    }
    @Override public String toString() {
      return asyncCache.cache().toString();
    }

    private final class AsyncEntrySet extends AbstractSet<Entry<K, CompletableFuture<V>>> {
      @Override public int size() {
        return AsyncAsMapView.this.size();
      }
      @Override public boolean isEmpty() {
        return AsyncAsMapView.this.isEmpty();
      }
      @Override public void clear() {
        AsyncAsMapView.this.clear();
      }
      @Override public boolean contains(@Nullable Object o) {
        return asyncCache.cache().entrySet().contains(o);
      }
      @Override public boolean containsAll(Collection<?> collection) {
        return (collection == this) || asyncCache.cache().entrySet().containsAll(collection);
      }
      @Override public boolean remove(@Nullable Object o) {
        return asyncCache.cache().entrySet().remove(o);
      }
      @Override public boolean removeAll(Collection<?> collection) {
        return asyncCache.cache().entrySet().removeAll(collection);
      }
      @Override public boolean retainAll(Collection<?> collection) {
        return asyncCache.cache().entrySet().retainAll(collection);
      }
      @Override public boolean removeIf(Predicate<? super Entry<K, CompletableFuture<V>>> filter) {
        return asyncCache.cache().entrySet().removeIf(filter);
      }
      @Override public Iterator<Entry<K, CompletableFuture<V>>> iterator() {
        return new AsyncEntryIterator();
      }
      @Override public Spliterator<Entry<K, CompletableFuture<V>>> spliterator() {
        return new AsyncEntrySpliterator();
      }
    }

    private final class AsyncEntryIterator implements Iterator<Entry<K, CompletableFuture<V>>> {
      final Iterator<Entry<K, CompletableFuture<V>>> iterator =
          asyncCache.cache().entrySet().iterator();

      @Override public boolean hasNext() {
        return iterator.hasNext();
      }
      @Override public Entry<K, CompletableFuture<V>> next() {
        var entry = iterator.next();
        return new WriteThroughEntry<>(AsyncAsMapView.this, entry.getKey(), entry.getValue());
      }
      @Override public void remove() {
        iterator.remove();
      }
    }

    private final class AsyncEntrySpliterator
        implements Spliterator<Entry<K, CompletableFuture<V>>> {
      final Spliterator<Entry<K, CompletableFuture<V>>> spliterator;

      AsyncEntrySpliterator() {
        this(asyncCache.cache().entrySet().spliterator());
      }
      AsyncEntrySpliterator(Spliterator<Entry<K, CompletableFuture<V>>> spliterator) {
        this.spliterator = requireNonNull(spliterator);
      }
      @Override public boolean tryAdvance(Consumer<? super Entry<K, CompletableFuture<V>>> action) {
        requireNonNull(action);
        return spliterator.tryAdvance(entry -> action.accept(
            new WriteThroughEntry<>(AsyncAsMapView.this, entry.getKey(), entry.getValue())));
      }
      @Override public void forEachRemaining(
          Consumer<? super Entry<K, CompletableFuture<V>>> action) {
        requireNonNull(action);
        spliterator.forEachRemaining(entry -> action.accept(
            new WriteThroughEntry<>(AsyncAsMapView.this, entry.getKey(), entry.getValue())));
      }
      @Override public @Nullable Spliterator<Entry<K, CompletableFuture<V>>> trySplit() {
        var split = spliterator.trySplit();
        return (split == null) ? null : new AsyncEntrySpliterator(split);
      }
      @Override public long estimateSize() {
        return spliterator.estimateSize();
      }
      @Override public int characteristics() {
        return spliterator.characteristics();
      }
    }
  }

  /* --------------- Synchronous view --------------- */
  final class CacheView<K, V> extends AbstractCacheView<K, V> {
    private static final long serialVersionUID = 1L;

    @SuppressWarnings("serial")
    final LocalAsyncCache<K, V> asyncCache;

    CacheView(LocalAsyncCache<K, V> asyncCache) {
      this.asyncCache = requireNonNull(asyncCache);
    }
    @Override LocalAsyncCache<K, V> asyncCache() {
      return asyncCache;
    }
  }

  abstract class AbstractCacheView<K, V> implements Cache<K, V>, Serializable {
    private static final long serialVersionUID = 1L;

    transient @Nullable ConcurrentMap<K, V> asMapView;

    abstract LocalAsyncCache<K, V> asyncCache();

    @Override
    public @Nullable V getIfPresent(K key) {
      var future = asyncCache().cache().getIfPresent(key, /* recordStats= */ false);
      var value = Async.getIfReady(future);
      if (value == null) {
        asyncCache().cache().statsCounter().recordMisses(1);
      } else {
        asyncCache().cache().statsCounter().recordHits(1);
      }
      return value;
    }

    @Override
    public Map<K, V> getAllPresent(Iterable<? extends K> keys) {
      var result = new LinkedHashMap<K, @Nullable V>(calculateHashMapCapacity(keys));
      for (K key : keys) {
        result.put(key, null);
      }

      int uniqueKeys = result.size();
      for (var iter = result.entrySet().iterator(); iter.hasNext();) {
        Map.Entry<K, @Nullable V> entry = iter.next();

        CompletableFuture<V> future = asyncCache().cache().get(entry.getKey());
        V value = Async.getIfReady(future);
        if (value == null) {
          iter.remove();
        } else {
          entry.setValue(value);
        }
      }
      asyncCache().cache().statsCounter().recordHits(result.size());
      asyncCache().cache().statsCounter().recordMisses(uniqueKeys - result.size());

      @SuppressWarnings({"NullableProblems", "NullAway"})
      Map<K, V> unmodifiable = Collections.unmodifiableMap(result);
      return unmodifiable;
    }

    @Override
    public V get(K key, Function<? super K, ? extends V> mappingFunction) {
      return resolve(asyncCache().get(key, mappingFunction));
    }

    @Override
    public Map<K, V> getAll(
        Iterable<? extends K> keys,
        Function<
            ? super Set<? extends K>,
            ? extends Map<? extends K, ? extends V>> mappingFunction) {
      return resolve(asyncCache().getAll(keys, mappingFunction));
    }

    @SuppressWarnings({"PMD.AvoidThrowingNullPointerException",
      "PMD.PreserveStackTrace", "UnusedException"})
    protected static <T> T resolve(CompletableFuture<T> future) {
      try {
        return future.join();
      } catch (NullMapCompletionException e) {
        throw new NullPointerException("null map");
      } catch (CompletionException e) {
        var cause = e.getCause();
        if (cause instanceof RuntimeException) {
          throw (RuntimeException) cause;
        } else if (cause instanceof Error) {
          throw (Error) cause;
        }
        throw e;
      }
    }

    @Override
    public void put(K key, V value) {
      requireNonNull(value);
      asyncCache().cache().put(key, CompletableFuture.completedFuture(value));
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> map) {
      map.forEach(this::put);
    }

    @Override
    public void invalidate(K key) {
      asyncCache().cache().remove(key);
    }

    @Override
    public void invalidateAll(Iterable<? extends K> keys) {
      asyncCache().cache().invalidateAll(keys);
    }

    @Override
    public void invalidateAll() {
      asyncCache().cache().clear();
    }

    @Override
    public long estimatedSize() {
      return asyncCache().cache().estimatedSize();
    }

    @Override
    public CacheStats stats() {
      return asyncCache().cache().statsCounter().snapshot();
    }

    @Override
    public void cleanUp() {
      asyncCache().cache().cleanUp();
    }

    @Override
    public Policy<K, V> policy() {
      return asyncCache().policy();
    }

    @Override
    public ConcurrentMap<K, V> asMap() {
      var mv = asMapView;
      return (mv == null) ? (asMapView = new AsMapView<>(asyncCache().cache())) : mv;
    }

    private void readObject(ObjectInputStream stream) throws InvalidObjectException {
      throw new InvalidObjectException("Proxy required");
    }

    @SuppressWarnings("unused")
    private void readObjectNoData() throws InvalidObjectException {
      throw new InvalidObjectException("Proxy required");
    }

    Object writeReplace() {
      return new SyncViewProxy<>(asyncCache());
    }
  }

  final class AsMapView<K, V> implements ConcurrentMap<K, V> {
    final LocalCache<K, CompletableFuture<V>> delegate;

    @Nullable Set<K> keys;
    @Nullable Collection<V> values;
    @Nullable Set<Entry<K, V>> entries;

    AsMapView(LocalCache<K, CompletableFuture<V>> delegate) {
      this.delegate = delegate;
    }

    @Override
    public boolean isEmpty() {
      return delegate.isEmpty();
    }

    @Override
    public int size() {
      return delegate.size();
    }

    @Override
    public void clear() {
      delegate.clear();
    }

    @Override
    public boolean containsKey(@Nullable Object key) {
      requireNonNull(key);
      return Async.isReady(delegate.getIfPresentQuietly(key));
    }

    @Override
    public boolean containsValue(@Nullable Object value) {
      requireNonNull(value);

      for (CompletableFuture<V> valueFuture : delegate.values()) {
        if (value.equals(Async.getIfReady(valueFuture))) {
          return true;
        }
      }
      return false;
    }

    @Override
    public @Nullable V get(@Nullable Object key) {
      return Async.getIfReady(delegate.get(key));
    }

    @Override
    @SuppressWarnings("ResultOfMethodCallIgnored")
    public @Nullable V putIfAbsent(K key, V value) {
      requireNonNull(value);

      // Keep in sync with BoundedVarExpiration.putIfAbsentAsync(key, value, duration, unit)
      var probe = delegate.putIfAbsent(key, CompletableFuture.completedFuture(value));
      V present = Async.getIfReady(probe);
      if ((probe == null) || (present != null)) {
        return present;
      }

      for (;;) {
        var priorFuture = delegate.getIfPresentQuietly(key);
        if (priorFuture != null) {
          if (!priorFuture.isDone()) {
            Async.getWhenSuccessful(priorFuture);
            continue;
          }

          V prior = Async.getWhenSuccessful(priorFuture);
          if (prior != null) {
            return prior;
          }
        }

        boolean[] added = { false };
        var hints = new LocalCache.RemapHints();
        CompletableFuture<V> computed = delegate.compute(
            key, (K k, @Nullable CompletableFuture<V> valueFuture) -> {
              added[0] = (valueFuture == null)
                  || (valueFuture.isDone() && (Async.getIfReady(valueFuture) == null));
              if (added[0]) {
                return CompletableFuture.completedFuture(value);
              }
              hints.preserveEntry();
              return valueFuture;
            }, delegate.expiry(), /* recordLoad= */ false, hints);

        if (added[0]) {
          return null;
        } else {
          V prior = Async.getWhenSuccessful(computed);
          if (prior != null) {
            return prior;
          }
        }
      }
    }

    @Override
    @SuppressWarnings("ResultOfMethodCallIgnored")
    public void putAll(Map<? extends K, ? extends V> map) {
      map.forEach(this::put);
    }

    @Override
    public @Nullable V put(K key, V value) {
      requireNonNull(value);
      CompletableFuture<V> oldValueFuture =
          delegate.put(key, CompletableFuture.completedFuture(value));
      return Async.getWhenSuccessful(oldValueFuture);
    }

    @Override
    public @Nullable V remove(@Nullable Object key) {
      CompletableFuture<V> oldValueFuture = delegate.remove(key);
      return Async.getWhenSuccessful(oldValueFuture);
    }

    @Override
    public boolean remove(@Nullable Object key, @Nullable Object value) {
      requireNonNull(key);
      if (value == null) {
        return false;
      }

      @SuppressWarnings("unchecked")
      var castedKey = (K) key;
      boolean[] removed = { false };
      remapWhenSettled(castedKey, (oldValue, oldValueFuture) -> {
        removed[0] = Objects.equals(value, oldValue);
        return ((oldValue == null) || removed[0]) ? null : oldValueFuture;
      });
      return removed[0];
    }

    @Override
    public @Nullable V replace(K key, V value) {
      requireNonNull(value);

      @SuppressWarnings({"unchecked", "Varifier"})
      @Nullable V[] oldValue = (V[]) new Object[1];
      remapWhenSettled(key, (current, oldValueFuture) -> {
        oldValue[0] = current;
        return (current == null) ? null : CompletableFuture.completedFuture(value);
      });
      return oldValue[0];
    }

    @Override
    public boolean replace(K key, V oldValue, V newValue) {
      requireNonNull(oldValue);
      requireNonNull(newValue);

      boolean[] replaced = { false };
      remapWhenSettled(key, (current, oldValueFuture) -> {
        replaced[0] = Objects.equals(oldValue, current);
        return replaced[0] ? CompletableFuture.completedFuture(newValue) : oldValueFuture;
      });
      return replaced[0];
    }

    @Override
    @SuppressWarnings("ResultOfMethodCallIgnored")
    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
      requireNonNull(function);
      for (K key : keySet()) {
        computeIfPresent(key, (k, oldValue) ->
            requireNonNull(function.apply(k, oldValue)), /* recordLoad= */ false);
      }
    }

    /**
     * Applies the remapping to the entry once its value has settled, retrying while a load is in
     * flight. A remapping that returns the future it was given is a no-op, leaving the entry's
     * metadata and any in-flight refresh intact.
     *
     * @param key the key whose entry is to be remapped
     * @param remapping computes the future to store from the settled value, or {@code null} to
     *        remove the entry
     */
    @SuppressWarnings("ResultOfMethodCallIgnored")
    private void remapWhenSettled(K key,
        BiFunction<@Nullable V, CompletableFuture<V>, @Nullable CompletableFuture<V>> remapping) {
      boolean[] done = { false };
      for (;;) {
        CompletableFuture<V> future = delegate.getIfPresentQuietly(key);
        if ((future == null) || future.isCompletedExceptionally()) {
          return;
        }

        Async.getWhenSuccessful(future);
        var hints = new LocalCache.RemapHints();
        delegate.compute(key, (K k, @Nullable CompletableFuture<V> oldValueFuture) -> {
          if (oldValueFuture == null) {
            done[0] = true;
            return null;
          } else if (!oldValueFuture.isDone()) {
            hints.preserveEntry();
            return oldValueFuture;
          }

          done[0] = true;
          var remapped = remapping.apply(Async.getIfReady(oldValueFuture), oldValueFuture);
          if (remapped == oldValueFuture) {
            hints.preserveEntry();
          }
          return remapped;
        }, delegate.expiry(), /* recordLoad= */ false, hints);

        if (done[0]) {
          return;
        }
      }
    }

    @Override
    @SuppressWarnings("ResultOfMethodCallIgnored")
    public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
      requireNonNull(mappingFunction);

      @Var CompletableFuture<V> priorFuture = null;
      for (;;) {
        priorFuture = (priorFuture == null)
            ? delegate.get(key)
            : delegate.getIfPresentQuietly(key);
        if (priorFuture != null) {
          if (!priorFuture.isDone()) {
            Async.getWhenSuccessful(priorFuture);
            continue;
          }

          V prior = Async.getWhenSuccessful(priorFuture);
          if (prior != null) {
            delegate.statsCounter().recordHits(1);
            return prior;
          }
        }

        @SuppressWarnings({"rawtypes", "unchecked"})
        CompletableFuture<V>[] future = new CompletableFuture[1];
        var hints = new LocalCache.RemapHints();
        CompletableFuture<V> computed = delegate.compute(
            key, (K k, @Nullable CompletableFuture<V> valueFuture) -> {
              if ((valueFuture != null)
                  && (!valueFuture.isDone() || (Async.getIfReady(valueFuture) != null))) {
                hints.preserveEntry();
                return valueFuture;
              }

              V newValue = delegate.statsAware(mappingFunction, /* recordLoad= */ true).apply(key);
              if (newValue == null) {
                return null;
              }
              future[0] = CompletableFuture.completedFuture(newValue);
              return future[0];
            }, delegate.expiry(), /* recordLoad= */ false, hints);

        V result = Async.getWhenSuccessful(computed);
        if ((computed == future[0]) || (result != null)) {
          return castNonNull(result);
        }
      }
    }

    @Override
    public @Nullable V computeIfPresent(K key,
        BiFunction<? super K, ? super V, ? extends @Nullable V> remappingFunction) {
      return computeIfPresent(key, remappingFunction, /* recordLoad= */ true);
    }

    @SuppressWarnings("ResultOfMethodCallIgnored")
    private @Nullable V computeIfPresent(K key,
        BiFunction<? super K, ? super V, ? extends @Nullable V> remappingFunction,
        boolean recordLoad) {
      requireNonNull(remappingFunction);

      @SuppressWarnings({"unchecked", "Varifier"})
      @Nullable V[] newValue = (@Nullable V[]) new Object[1];
      for (;;) {
        Async.getWhenSuccessful(delegate.getIfPresentQuietly(key));

        var hints = new LocalCache.RemapHints();
        CompletableFuture<V> valueFuture = delegate.compute(
            key, (K k, @Nullable CompletableFuture<V> oldValueFuture) -> {
              if (oldValueFuture == null) {
                return null;
              } else if (!oldValueFuture.isDone()) {
                hints.preserveEntry();
                return oldValueFuture;
              }

              V oldValue = Async.getIfReady(oldValueFuture);
              if (oldValue == null) {
                return null;
              }

              BiFunction<? super K, ? super V, ? extends @Nullable V> function =
                  delegate.statsAware(remappingFunction, recordLoad);
              newValue[0] = function.apply(key, oldValue);
              return (newValue[0] == null) ? null : CompletableFuture.completedFuture(newValue[0]);
            }, delegate.expiry(), /* recordLoad= */ false, hints);

        if (newValue[0] != null) {
          return newValue[0];
        } else if (valueFuture == null) {
          return null;
        }
      }
    }

    @Override
    @SuppressWarnings("ResultOfMethodCallIgnored")
    public @Nullable V compute(K key,
        BiFunction<? super K, ? super @Nullable V, ? extends @Nullable V> remappingFunction) {
      // Keep in sync with BoundedVarExpiration.computeAsync(key, remappingFunction, expiry)
      requireNonNull(remappingFunction);

      @SuppressWarnings({"unchecked", "Varifier"})
      @Nullable V[] newValue = (@Nullable V[]) new Object[1];
      for (;;) {
        Async.getWhenSuccessful(delegate.getIfPresentQuietly(key));

        var hints = new LocalCache.RemapHints();
        CompletableFuture<V> valueFuture = delegate.compute(
            key, (K k, @Nullable CompletableFuture<V> oldValueFuture) -> {
              if ((oldValueFuture != null) && !oldValueFuture.isDone()) {
                hints.preserveEntry();
                return oldValueFuture;
              }

              V oldValue = Async.getIfReady(oldValueFuture);
              BiFunction<? super K, ? super @Nullable V, ? extends @Nullable V> function =
                  delegate.statsAware(remappingFunction, /* recordLoad= */ true);
              newValue[0] = function.apply(key, oldValue);
              return (newValue[0] == null) ? null : CompletableFuture.completedFuture(newValue[0]);
            }, delegate.expiry(), /* recordLoad= */ false, hints);

        if (newValue[0] != null) {
          return newValue[0];
        } else if (valueFuture == null) {
          return null;
        }
      }
    }

    @Override
    @SuppressWarnings("ResultOfMethodCallIgnored")
    public @Nullable V merge(K key, V value,
        BiFunction<? super V, ? super V, ? extends @Nullable V> remappingFunction) {
      requireNonNull(value);
      requireNonNull(remappingFunction);

      CompletableFuture<V> newValueFuture = CompletableFuture.completedFuture(value);
      boolean[] merged = { false };
      for (;;) {
        Async.getWhenSuccessful(delegate.getIfPresentQuietly(key));

        var hints = new LocalCache.RemapHints();
        CompletableFuture<V> mergedValueFuture = delegate.compute(
            key, (K k, @Nullable CompletableFuture<V> oldValueFuture) -> {
              if (oldValueFuture == null) {
                merged[0] = true;
                return newValueFuture;
              } else if (!oldValueFuture.isDone()) {
                hints.preserveEntry();
                return oldValueFuture;
              }

              merged[0] = true;
              V oldValue = Async.getIfReady(oldValueFuture);
              if (oldValue == null) {
                return newValueFuture;
              }
              V mergedValue = delegate.statsAware(remappingFunction).apply(oldValue, value);
              if (mergedValue == null) {
                return null;
              } else if (mergedValue == oldValue) {
                return oldValueFuture;
              } else if (mergedValue == value) {
                return newValueFuture;
              }
              return CompletableFuture.completedFuture(mergedValue);
            }, delegate.expiry(), /* recordLoad= */ false, hints);

        if (merged[0]) {
          return Async.getWhenSuccessful(mergedValueFuture);
        }
      }
    }

    @Override
    public Set<K> keySet() {
      var ks = keys;
      return (ks == null) ? (keys = new KeySet()) : ks;
    }

    @Override
    public Collection<V> values() {
      var vs = values;
      return (vs == null) ? (values = new Values()) : vs;
    }

    @Override
    public Set<Entry<K, V>> entrySet() {
      var es = entries;
      return (es == null) ? (entries = new EntrySet()) : es;
    }

    /** See {@link BoundedLocalCache#equals(Object)} for semantics. */
    @Override
    public boolean equals(@Nullable Object o) {
      if (o == this) {
        return true;
      } else if (!(o instanceof Map)) {
        return false;
      }

      var map = (Map<?, ?>) o;
      int expectedSize = size();
      if (map.size() != expectedSize) {
        return false;
      }

      @Var int count = 0;
      try {
        for (var iterator = new EntryIterator(); iterator.hasNext();) {
          var entry = iterator.next();
          var value = map.get(entry.getKey());
          if ((value == null) || ((value != entry.getValue()) && !value.equals(entry.getValue()))) {
            return false;
          }
          count++;
        }
      } catch (ClassCastException | NullPointerException ignored) {
        return false;
      }
      return (count == expectedSize);
    }

    @Override
    public int hashCode() {
      @Var int hash = 0;
      for (var iterator = new EntryIterator(); iterator.hasNext();) {
        var entry = iterator.next();
        hash += entry.hashCode();
      }
      return hash;
    }

    @Override
    public String toString() {
      var result = new StringBuilder(50).append('{');
      for (var iterator = new EntryIterator(); iterator.hasNext();) {
        var entry = iterator.next();
        result.append((entry.getKey() == this) ? "(this Map)" : entry.getKey())
            .append('=')
            .append((entry.getValue() == this) ? "(this Map)" : entry.getValue());

        if (iterator.hasNext()) {
          result.append(", ");
        }
      }
      return result.append('}').toString();
    }

    private final class KeySet extends AbstractSet<K> {

      @Override
      public boolean isEmpty() {
        return AsMapView.this.isEmpty();
      }

      @Override
      public int size() {
        return AsMapView.this.size();
      }

      @Override
      public void clear() {
        AsMapView.this.clear();
      }

      @Override
      public boolean contains(@Nullable Object o) {
        return AsMapView.this.containsKey(o);
      }

      @Override
      public boolean containsAll(Collection<?> collection) {
        requireNonNull(collection);
        if (collection != this) {
          for (Object o : collection) {
            if ((o == null) || !contains(o)) {
              return false;
            }
          }
        }
        return true;
      }

      @Override
      public boolean removeAll(Collection<?> collection) {
        return delegate.keySet().removeAll(collection);
      }

      @Override
      public boolean remove(@Nullable Object o) {
        return (delegate.remove(o) != null);
      }

      @Override
      public boolean removeIf(Predicate<? super K> filter) {
        return delegate.keySet().removeIf(filter);
      }

      @Override
      public boolean retainAll(Collection<?> collection) {
        return delegate.keySet().retainAll(collection);
      }

      @Override
      public Iterator<K> iterator() {
        return new KeyIterator<>(new EntryIterator());
      }

      @Override
      public Spliterator<K> spliterator() {
        return new KeySpliterator<>(new EntrySpliterator());
      }
    }

    private static final class KeyIterator<K, V> implements Iterator<K> {
      private final Iterator<Entry<K, V>> iterator;

      KeyIterator(Iterator<Entry<K, V>> iterator) {
        this.iterator = requireNonNull(iterator);
      }

      @Override
      public boolean hasNext() {
        return iterator.hasNext();
      }

      @Override
      public K next() {
        return iterator.next().getKey();
      }

      @Override
      public void remove() {
        iterator.remove();
      }
    }

    private static final class KeySpliterator<K, V> implements Spliterator<K> {
      private final Spliterator<Entry<K, V>> spliterator;

      KeySpliterator(Spliterator<Entry<K, V>> iterator) {
        this.spliterator = requireNonNull(iterator);
      }

      @Override
      public boolean tryAdvance(Consumer<? super K> action) {
        requireNonNull(action);
        return spliterator.tryAdvance(entry -> {
          action.accept(entry.getKey());
        });
      }

      @Override
      public @Nullable Spliterator<K> trySplit() {
        Spliterator<Entry<K, V>> split = spliterator.trySplit();
        return (split == null) ? null : new KeySpliterator<>(split);
      }

      @Override
      public long estimateSize() {
        return spliterator.estimateSize();
      }

      @Override
      public int characteristics() {
        return DISTINCT | NONNULL | CONCURRENT;
      }
    }

    private final class Values extends AbstractCollection<V> {

      @Override
      public boolean isEmpty() {
        return AsMapView.this.isEmpty();
      }

      @Override
      public int size() {
        return AsMapView.this.size();
      }

      @Override
      public void clear() {
        AsMapView.this.clear();
      }

      @Override
      public boolean contains(@Nullable Object o) {
        return AsMapView.this.containsValue(o);
      }

      @Override
      public boolean containsAll(Collection<?> collection) {
        requireNonNull(collection);
        if (collection != this) {
          for (Object o : collection) {
            if ((o == null) || !contains(o)) {
              return false;
            }
          }
        }
        return true;
      }

      @Override
      public boolean removeAll(Collection<?> collection) {
        requireNonNull(collection);
        @Var boolean modified = false;
        for (var entry : delegate.entrySet()) {
          V value = Async.getIfReady(entry.getValue());
          if ((value != null) && collection.contains(value)
              && AsMapView.this.remove(entry.getKey(), value)) {
            modified = true;
          }
        }
        return modified;
      }

      @Override
      public boolean remove(@Nullable Object o) {
        if (o == null) {
          return false;
        }
        for (var entry : delegate.entrySet()) {
          V value = Async.getIfReady(entry.getValue());
          if (o.equals(value) && AsMapView.this.remove(entry.getKey(), value)) {
            return true;
          }
        }
        return false;
      }

      @Override
      public boolean removeIf(Predicate<? super V> filter) {
        requireNonNull(filter);
        return delegate.values().removeIf(future -> {
          V value = Async.getIfReady(future);
          return (value != null) && filter.test(value);
        });
      }

      @Override
      public boolean retainAll(Collection<?> collection) {
        requireNonNull(collection);
        @Var boolean modified = false;
        for (var entry : delegate.entrySet()) {
          V value = Async.getIfReady(entry.getValue());
          if ((value != null) && !collection.contains(value)
              && AsMapView.this.remove(entry.getKey(), value)) {
            modified = true;
          }
        }
        return modified;
      }

      @Override
      public void forEach(Consumer<? super V> action) {
        requireNonNull(action);
        delegate.values().forEach(future -> {
          V value = Async.getIfReady(future);
          if (value != null) {
            action.accept(value);
          }
        });
      }

      @Override
      public Iterator<V> iterator() {
        return new ValueIterator<>(new EntryIterator());
      }

      @Override
      public Spliterator<V> spliterator() {
        return new ValueSpliterator<>(new EntrySpliterator());
      }
    }

    private static final class ValueIterator<K, V> implements Iterator<V> {
      private final Iterator<Entry<K, V>> iterator;

      ValueIterator(Iterator<Entry<K, V>> iterator) {
        this.iterator = requireNonNull(iterator);
      }

      @Override
      public boolean hasNext() {
        return iterator.hasNext();
      }

      @Override
      public V next() {
        return iterator.next().getValue();
      }

      @Override
      public void remove() {
        iterator.remove();
      }
    }

    private static final class ValueSpliterator<K, V> implements Spliterator<V> {
      private final Spliterator<Entry<K, V>> spliterator;

      ValueSpliterator(Spliterator<Entry<K, V>> iterator) {
        this.spliterator = requireNonNull(iterator);
      }

      @Override
      public boolean tryAdvance(Consumer<? super V> action) {
        requireNonNull(action);
        return spliterator.tryAdvance(entry -> {
          action.accept(entry.getValue());
        });
      }

      @Override
      public @Nullable Spliterator<V> trySplit() {
        Spliterator<Entry<K, V>> split = spliterator.trySplit();
        return (split == null) ? null : new ValueSpliterator<>(split);
      }

      @Override
      public long estimateSize() {
        return spliterator.estimateSize();
      }

      @Override
      public int characteristics() {
        return NONNULL | CONCURRENT;
      }
    }

    private final class EntrySet extends AbstractSet<Entry<K, V>> {

      @Override
      public boolean isEmpty() {
        return AsMapView.this.isEmpty();
      }

      @Override
      public int size() {
        return AsMapView.this.size();
      }

      @Override
      public void clear() {
        AsMapView.this.clear();
      }

      @Override
      public boolean contains(@Nullable Object o) {
        if (!(o instanceof Entry<?, ?>)) {
          return false;
        }
        var entry = (Entry<?, ?>) o;
        var key = entry.getKey();
        var value = entry.getValue();
        if ((key == null) || (value == null)) {
          return false;
        }
        V cachedValue = Async.getIfReady(delegate.getIfPresentQuietly(key));
        return value.equals(cachedValue);
      }

      @Override
      public boolean containsAll(Collection<?> collection) {
        requireNonNull(collection);
        if (collection != this) {
          for (Object o : collection) {
            if ((o == null) || !contains(o)) {
              return false;
            }
          }
        }
        return true;
      }

      @Override
      public boolean removeAll(Collection<?> collection) {
        requireNonNull(collection);
        @Var boolean modified = false;
        if (delegate.collectKeys()
            || ((collection instanceof Set<?>) && (collection.size() > size()))) {
          for (var entry : this) {
            if (collection.contains(entry)) {
              modified |= remove(entry);
            }
          }
        } else {
          for (var o : collection) {
            modified |= remove(o);
          }
        }
        return modified;
      }

      @Override
      public boolean remove(@Nullable Object obj) {
        if (!(obj instanceof Entry<?, ?>)) {
          return false;
        }
        var entry = (Entry<?, ?>) obj;
        var key = entry.getKey();
        return (key != null) && AsMapView.this.remove(key, entry.getValue());
      }

      @Override
      public boolean removeIf(Predicate<? super Entry<K, V>> filter) {
        requireNonNull(filter);
        return delegate.entrySet().removeIf(entry -> {
          V value = Async.getIfReady(entry.getValue());
          return (value != null) && filter.test(Map.entry(entry.getKey(), value));
        });
      }

      @Override
      public boolean retainAll(Collection<?> collection) {
        requireNonNull(collection);
        @Var boolean modified = false;
        for (var entry : this) {
          if (!collection.contains(entry) && remove(entry)) {
            modified = true;
          }
        }
        return modified;
      }

      @Override
      public Iterator<Entry<K, V>> iterator() {
        return new EntryIterator();
      }

      @Override
      public Spliterator<Entry<K, V>> spliterator() {
        return new EntrySpliterator();
      }
    }

    private final class EntryIterator implements Iterator<Entry<K, V>> {
      final Iterator<Entry<K, CompletableFuture<V>>> iterator;
      @Nullable Entry<K, V> cursor;
      @Nullable K removalKey;

      EntryIterator() {
        this.iterator = delegate.entrySet().iterator();
      }

      @Override
      public boolean hasNext() {
        while ((cursor == null) && iterator.hasNext()) {
          Entry<K, CompletableFuture<V>> entry = iterator.next();
          V value = Async.getIfReady(entry.getValue());
          if (value != null) {
            cursor = new WriteThroughEntry<>(AsMapView.this, entry.getKey(), value);
          }
        }
        return (cursor != null);
      }

      @Override
      public Entry<K, V> next() {
        if (!hasNext()) {
          throw new NoSuchElementException();
        }
        K key = requireNonNull(cursor).getKey();
        Entry<K, V> entry = cursor;
        removalKey = key;
        cursor = null;
        return entry;
      }

      @Override
      public void remove() {
        requireState(removalKey != null);
        delegate.remove(removalKey);
        removalKey = null;
      }
    }

    private final class EntrySpliterator implements Spliterator<Entry<K, V>> {
      final Spliterator<Entry<K, CompletableFuture<V>>> spliterator;

      EntrySpliterator() {
        this(delegate.entrySet().spliterator());
      }

      EntrySpliterator(Spliterator<Entry<K, CompletableFuture<V>>> spliterator) {
        this.spliterator = requireNonNull(spliterator);
      }

      @Override
      public void forEachRemaining(Consumer<? super Entry<K, V>> action) {
        requireNonNull(action);
        spliterator.forEachRemaining(entry -> {
          V value = Async.getIfReady(entry.getValue());
          if (value != null) {
            var e = new WriteThroughEntry<>(AsMapView.this, entry.getKey(), value);
            action.accept(e);
          }
        });
      }

      @Override
      public boolean tryAdvance(Consumer<? super Entry<K, V>> action) {
        requireNonNull(action);
        boolean[] advanced = { false };
        Consumer<? super Entry<K, CompletableFuture<V>>> consumer = entry -> {
          V value = Async.getIfReady(entry.getValue());
          if (value != null) {
            var e = new WriteThroughEntry<>(AsMapView.this, entry.getKey(), value);
            action.accept(e);
            advanced[0] = true;
          }
        };
        while (spliterator.tryAdvance(consumer)) {
          if (advanced[0]) {
            return true;
          }
        }
        return false;
      }

      @Override
      public @Nullable Spliterator<Entry<K, V>> trySplit() {
        Spliterator<Entry<K, CompletableFuture<V>>> split = spliterator.trySplit();
        return (split == null) ? null : new EntrySpliterator(split);
      }

      @Override
      public long estimateSize() {
        return spliterator.estimateSize();
      }

      @Override
      public int characteristics() {
        return DISTINCT | CONCURRENT | NONNULL;
      }
    }
  }

  @SuppressWarnings("serial")
  final class SyncViewProxy<K, V> implements Serializable {
    private static final long serialVersionUID = 1;

    final AsyncCache<K, V> asyncCache;

    SyncViewProxy(AsyncCache<K, V> asyncCache) {
      this.asyncCache = requireNonNull(asyncCache);
    }

    @SuppressWarnings("unused")
    private void readObject(ObjectInputStream stream)
        throws IOException, ClassNotFoundException {
      stream.defaultReadObject();
      if (asyncCache == null) {
        throw new InvalidObjectException("asyncCache required");
      }
    }

    Object readResolve() {
      return asyncCache.synchronous();
    }
  }
}

ben-manes / caffeine / #5836

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous