#5826

Committed 14 Oct 2026 08:43PM UTC coverage: 99.978% (-0.02%) from 100.0%

Build # #5826

Build Type

push

github

Committed by

ben-manes

Commit Message

remove the JDK's timer when the pacer cancels

Scheduler.systemScheduler() went through delayedExecutor, which keeps
no handle to its delayed task, so the pacer's cancel left that task
queued until its original fire time. A cache that emptied and refilled
stranded one task per cycle, about 900 bytes each, for up to its
expiration duration.

The system scheduler now arms an internal future with orTimeout, whose
timeout completes the returned future and submits the task. Completing
the returned future, as a cancel does, completes the timer normally,
the only completion on which JDK 11, and 17 before 17.0.14, remove it.

The JDK-seam audit's findings that need no change are recorded as
rulings, and the skill is kept for manual runs.

Coverage Stats

4826 of 4834 branches covered (99.83%)

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

2 existing lines in 2 files now uncovered.

9277 of 9279 relevant lines covered (99.98%)

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.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);
    }
  }

  /**
   * 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);
        }
      }
    });
  }

  /** 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);
    }

    @SuppressWarnings("ImmutableMapCopyOf")
    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 = Map.copyOf(result);
      } catch (Throwable t) {
        failProxies(t);
        return t;
      }

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

    /** 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);
      }
      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);
      }
      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);
      }
      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({"rawtypes", "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({"rawtypes", "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({"rawtypes", "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 / #5826

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