#5834

Committed 20 Oct 2026 06:36AM UTC coverage: 99.979% (-0.01%) from 99.989%

Build # #5834

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%)

2 existing lines in 2 files now uncovered.

9347 of 9349 relevant lines covered (99.98%)

1.0 hits per line

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

99.83

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

/*
 * Copyright 2014 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.LocalCache.castNonNull;
import static com.github.benmanes.caffeine.cache.LocalLoadingCache.newBulkMappingFunction;
import static com.github.benmanes.caffeine.cache.LocalLoadingCache.newMappingFunction;
import static java.lang.invoke.ConstantBootstraps.fieldVarHandle;
import static java.util.Objects.requireNonNull;

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.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.Spliterator;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Executor;
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.stats.StatsCounter;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.Var;

/**
 * An in-memory cache that has no capabilities for bounding the map. This implementation provides
 * a lightweight wrapper on top of {@link ConcurrentHashMap}.
 *
 * @author ben.manes@gmail.com (Ben Manes)
 */
@SuppressWarnings("serial")
final class UnboundedLocalCache<K, V> implements LocalCache<K, V> {
  static final Logger logger = System.getLogger(UnboundedLocalCache.class.getName());
  static final VarHandle REFRESHES = fieldVarHandle(MethodHandles.lookup(),
      "refreshes", VarHandle.class, UnboundedLocalCache.class, ConcurrentMap.class);

  final @Nullable RemovalListener<K, V> removalListener;
  final ConcurrentHashMap<K, V> data;
  final StatsCounter statsCounter;
  final boolean isRecordingStats;
  final Executor executor;
  final boolean isAsync;

  @Nullable Set<K> keySet;
  @Nullable Collection<V> values;
  @Nullable Set<Entry<K, V>> entrySet;
  volatile @Nullable ConcurrentMap<Object, CompletableFuture<?>> refreshes;

  UnboundedLocalCache(Caffeine<? super K, ? super V> builder, boolean isAsync) {
    this.data = new ConcurrentHashMap<>(builder.getInitialCapacity());
    this.statsCounter = builder.getStatsCounterSupplier().get();
    this.removalListener = builder.getRemovalListener(isAsync);
    this.isRecordingStats = builder.isRecordingStats();
    this.executor = builder.getExecutor();
    this.isAsync = isAsync;
  }

  @Override
  public boolean isAsync() {
    return isAsync;
  }

  @Override
  public @Nullable RemovalListener<K, V> removalListener() {
    return removalListener;
  }

  @Override
  public @Nullable Expiry<K, V> expiry() {
    return null;
  }

  @Override
  public boolean collectKeys() {
    return false;
  }

  @Override
  @CanIgnoreReturnValue
  public Object referenceKey(K key) {
    return key;
  }

  @Override
  public boolean isPendingEviction(K key) {
    return false;
  }

  /* --------------- Cache --------------- */

  @Override
  @SuppressWarnings("SuspiciousMethodCalls")
  public @Nullable V getIfPresent(Object key, boolean recordStats) {
    V value = data.get(key);

    if (recordStats) {
      if (value == null) {
        statsCounter.recordMisses(1);
      } else {
        statsCounter.recordHits(1);
      }
    }
    return value;
  }

  @Override
  @SuppressWarnings("SuspiciousMethodCalls")
  public @Nullable V getIfPresentQuietly(Object key) {
    return data.get(key);
  }

  @Override
  public long estimatedSize() {
    return data.mappingCount();
  }

  @Override
  public int getAllPresent(Map<K, @Nullable V> result, boolean retainAbsent) {
    @Var int absent = 0;
    int uniqueKeys = result.size();
    for (var iter = result.entrySet().iterator(); iter.hasNext();) {
      Map.Entry<K, @Nullable V> entry = iter.next();
      V value = data.get(entry.getKey());
      if (value != null) {
        entry.setValue(value);
        continue;
      }
      absent++;
      if (!retainAbsent) {
        iter.remove();
      }
    }
    statsCounter.recordHits(uniqueKeys - absent);
    statsCounter.recordMisses(absent);
    return absent;
  }

  @Override
  public void cleanUp() {}

  @Override
  public StatsCounter statsCounter() {
    return statsCounter;
  }

  @Override
  @SuppressWarnings("PMD.AvoidInstanceofChecksInCatchClause")
  public void notifyRemoval(@Nullable K key, @Nullable V value, RemovalCause cause) {
    var removalListener = removalListener();
    if (removalListener == null) {
      return;
    }
    Runnable task = () -> {
      try {
        removalListener.onRemoval(key, value, cause);
      } catch (Throwable t) {
        if (t instanceof InterruptedException) {
          Thread.currentThread().interrupt();
        }
        logger.log(Level.WARNING, "Exception thrown by removal listener", t);
      }
    };
    try {
      executor.execute(task);
    } catch (Throwable t) {
      logger.log(Level.ERROR, "Exception thrown when submitting removal listener", t);
      task.run();
    }
  }

  @Override
  public boolean isRecordingStats() {
    return isRecordingStats;
  }

  @Override
  public Executor executor() {
    return executor;
  }

  @Override
  public ConcurrentMap<Object, CompletableFuture<?>> refreshes() {
    @Var var pending = refreshes;
    if (pending == null) {
      pending = new ConcurrentHashMap<>();
      if (!REFRESHES.compareAndSet(this, null, pending)) {
        pending = requireNonNull(refreshes);
      }
    }
    return pending;
  }

  /** Invalidate the in-flight refresh. */
  void discardRefresh(Object keyReference) {
    var pending = refreshes;
    if (pending != null) {
      pending.remove(keyReference);
    }
  }

  @Override
  public Ticker statsTicker() {
    return isRecordingStats ? Ticker.systemTicker() : Ticker.disabledTicker();
  }

  /* --------------- JDK8+ Map extensions --------------- */

  @Override
  public void forEach(BiConsumer<? super K, ? super V> action) {
    data.forEach(action);
  }

  @Override
  @SuppressWarnings("ResultOfMethodCallIgnored")
  public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
    requireNonNull(function);

    BiFunction<K, @Nullable V, @Nullable V> remappingFunction = (key, oldValue) ->
        requireNonNull(function.apply(key, requireNonNull(oldValue)));
    for (K key : data.keySet()) {
      remap(key, remappingFunction, /* hints= */ null, /* computeIfAbsent= */ false);
    }
  }

  @Override
  public @Nullable V computeIfAbsent(K key,
      Function<? super K, ? extends @Nullable V> mappingFunction,
      boolean recordStats, boolean recordLoad) {
    requireNonNull(mappingFunction);

    // An optimistic fast path to avoid unnecessary locking
    @Var V value = data.get(key);
    if (value != null) {
      if (recordStats) {
        statsCounter.recordHits(1);
      }
      return value;
    }

    boolean[] missed = new boolean[1];
    value = data.computeIfAbsent(key, k -> {
      missed[0] = true;
      V computed = recordStats
          ? statsAware(mappingFunction, recordLoad).apply(k)
          : mappingFunction.apply(k);
      discardRefresh(k);
      return castNonNull(computed);
    });
    if (!missed[0] && recordStats) {
      statsCounter.recordHits(1);
    }
    return value;
  }

  @Override
  public @Nullable V computeIfPresent(K key,
      BiFunction<? super K, ? super V, ? extends @Nullable V> remappingFunction) {
    requireNonNull(remappingFunction);

    // An optimistic fast path to avoid unnecessary locking
    if (!data.containsKey(key)) {
      return null;
    }

    // ensures that the removal notification is processed after the removal has completed
    @SuppressWarnings({"unchecked", "Varifier"})
    @Nullable V[] oldValue = (V[]) new Object[1];
    V nv = data.computeIfPresent(key, (K k, V value) -> {
      BiFunction<? super K, ? super V, ? extends @Nullable V> function = statsAware(
          remappingFunction, /* recordLoad= */ true);
      try {
        V newValue = function.apply(k, value);
        if (newValue != value) {
          oldValue[0] = value;
        }

        discardRefresh(k);
        return newValue;
      } catch (Throwable t) {
        discardRefresh(k);
        throw t;
      }
    });
    if (nv != null) {
      notifyOnReplace(key, oldValue[0], nv);
    } else if (oldValue[0] != null) {
      notifyRemoval(key, oldValue[0], RemovalCause.EXPLICIT);
    }
    return nv;
  }

  @Override
  public @Nullable V compute(K key,
      BiFunction<? super K, ? super @Nullable V, ? extends @Nullable V> remappingFunction,
      @Nullable Expiry<? super K, ? super V> expiry, boolean recordLoad,
      @Nullable RemapHints hints) {
    requireNonNull(remappingFunction);
    return remap(key, statsAware(remappingFunction, recordLoad),
        hints, /* computeIfAbsent= */ true);
  }

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

    return remap(key, (K k, @Nullable V oldValue) ->
      (oldValue == null) ? value : statsAware(remappingFunction).apply(oldValue, value),
      /* hints= */ null, /* computeIfAbsent= */ true);
  }

  /**
   * A {@link Map#compute(Object, BiFunction)} that does not directly record any cache statistics.
   *
   * @param key key with which the specified value is to be associated
   * @param remappingFunction the function to compute a value
   * @param hints flags from a query-style caller, or {@code null} if not present
   * @param computeIfAbsent whether the caller may create an entry when the key is absent
   * @return the new value associated with the specified key, or null if none
   */
  @Nullable V remap(K key,
      BiFunction<? super K, ? super @Nullable V, ? extends @Nullable V> remappingFunction,
      @Nullable RemapHints hints, boolean computeIfAbsent) {
    // ensures that the removal notification is processed after the removal has completed
    @SuppressWarnings({"unchecked", "Varifier"})
    @Nullable V[] oldValue = (@Nullable V[]) new Object[1];
    V nv = data.compute(key, (K k, @Nullable V value) -> {
      if ((value == null) && !computeIfAbsent) {
        return null;
      }
      try {
        V newValue = remappingFunction.apply(k, value);
        if ((value == null) && (newValue == null)) {
          // A stale refresh whose entry is absent leaves a successor's registration intact
          if ((hints == null) || !hints.preserveRefresh) {
            discardRefresh(k);
          }
          return null;
        }

        if (newValue != value) {
          oldValue[0] = value;
        }

        // A query-style caller may flag a same-instance return as a no-op that must leave any
        // in-flight refresh intact whereas a real mutation discards a racing refresh so that a
        // stale reload cannot overwrite the new mapping.
        boolean preserveRefresh = (hints != null) && hints.preserveRefresh && (newValue == value);
        if (!preserveRefresh) {
          discardRefresh(k);
        }
        return newValue;
      } catch (Throwable t) {
        if (value != null) {
          discardRefresh(k);
        }
        throw t;
      }
    });
    if (nv != null) {
      notifyOnReplace(key, oldValue[0], nv);
    } else if (oldValue[0] != null) {
      notifyRemoval(key, oldValue[0], RemovalCause.EXPLICIT);
    }
    return nv;
  }

  /* --------------- Concurrent Map --------------- */

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

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

  @Override
  @SuppressWarnings("ResultOfMethodCallIgnored")
  public void clear() {
    var pending = refreshes;
    if (pending != null) {
      pending.clear();
    }

    var keys = (removalListener == null) ? data.keySet() : List.copyOf(data.keySet());
    for (K key : keys) {
      remove(key);
    }
  }

  @Override
  public boolean containsKey(@Nullable Object key) {
    requireNonNull(key);
    return data.containsKey(key);
  }

  @Override
  public boolean containsValue(@Nullable Object value) {
    requireNonNull(value);
    return data.containsValue(value);
  }

  @Override
  public @Nullable V get(@Nullable Object key) {
    requireNonNull(key);
    return getIfPresent(key, /* recordStats= */ false);
  }

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

    @SuppressWarnings({"unchecked", "Varifier"})
    @Nullable V[] oldValue = (@Nullable V[]) new Object[1];
    data.compute(key, (K k, @Nullable V v) -> {
      discardRefresh(k);
      oldValue[0] = v;
      return value;
    });
    if (oldValue[0] != null) {
      notifyOnReplace(key, oldValue[0], value);
    }
    return oldValue[0];
  }

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

    // An optimistic fast path to avoid unnecessary locking
    var v = data.get(key);
    if (v != null) {
      return v;
    }

    var added = new boolean[1];
    var val = data.computeIfAbsent(key, k -> {
      discardRefresh(k);
      added[0] = true;
      return value;
    });
    return added[0] ? null : val;
  }

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

  @Override
  public @Nullable V remove(@Nullable Object key) {
    requireNonNull(key);

    @SuppressWarnings("unchecked")
    var castKey = (K) key;
    @SuppressWarnings({"unchecked", "Varifier"})
    @Nullable V[] oldValue = (V[]) new Object[1];
    data.compute(castKey, (k, v) -> {
      discardRefresh(k);
      oldValue[0] = v;
      return null;
    });

    if (oldValue[0] != null) {
      notifyRemoval(castKey, oldValue[0], RemovalCause.EXPLICIT);
    }

    return oldValue[0];
  }

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

    @SuppressWarnings("unchecked")
    var castKey = (K) key;
    @SuppressWarnings({"unchecked", "Varifier"})
    @Nullable V[] oldValue = (V[]) new Object[1];

    data.computeIfPresent(castKey, (k, v) -> {
      if (Objects.equals(value, v)) {
        discardRefresh(k);
        oldValue[0] = v;
        return null;
      }
      return v;
    });

    if (oldValue[0] != null) {
      notifyRemoval(castKey, oldValue[0], RemovalCause.EXPLICIT);
      return true;
    }
    return false;
  }

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

    @SuppressWarnings({"unchecked", "Varifier"})
    @Nullable V[] oldValue = (@Nullable V[]) new Object[1];
    data.computeIfPresent(key, (k, v) -> {
      discardRefresh(k);
      oldValue[0] = v;
      return value;
    });

    notifyOnReplace(key, oldValue[0], value);
    return oldValue[0];
  }

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

    @SuppressWarnings({"unchecked", "Varifier"})
    @Nullable V[] prev = (V[]) new Object[1];
    data.computeIfPresent(key, (k, v) -> {
      if (Objects.equals(oldValue, v)) {
        if (shouldDiscardRefresh) {
          discardRefresh(k);
        }
        prev[0] = v;
        return newValue;
      }
      return v;
    });

    notifyOnReplace(key, prev[0], newValue);
    return (prev[0] != null);
  }

  @Override
  @SuppressWarnings("EqualsWhichDoesntCheckParameterClass")
  public boolean equals(@Nullable Object o) {
    if (o == this) {
      return true;
    }
    try {
      return data.equals(o);
    } catch (ClassCastException | NullPointerException ignored) {
      return false;
    }
  }

  @Override
  public int hashCode() {
    return data.hashCode();
  }

  @Override
  public String toString() {
    var result = new StringBuilder(50).append('{');
    data.forEach((key, value) -> {
      if (result.length() != 1) {
        result.append(", ");
      }
      result.append((key == this) ? "(this Map)" : key)
          .append('=')
          .append((value == this) ? "(this Map)" : value);
    });
    return result.append('}').toString();
  }

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

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

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

  /** An adapter to safely externalize the keys. */
  static final class KeySetView<K> extends AbstractSet<K> {
    final UnboundedLocalCache<K, ?> cache;

    KeySetView(UnboundedLocalCache<K, ?> cache) {
      this.cache = requireNonNull(cache);
    }

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

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

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

    @Override
    @SuppressWarnings("SuspiciousMethodCalls")
    public boolean contains(@Nullable Object o) {
      return cache.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) {
      requireNonNull(collection);
      @Var boolean modified = false;
      if ((collection instanceof Set<?>) && (collection.size() > size())) {
        for (K key : this) {
          if (collection.contains(key)) {
            modified |= remove(key);
          }
        }
      } else {
        for (var o : collection) {
          modified |= (o != null) && remove(o);
        }
      }
      return modified;
    }

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

    @Override
    public boolean removeIf(Predicate<? super K> filter) {
      requireNonNull(filter);
      @Var boolean modified = false;
      for (K key : this) {
        if (filter.test(key) && remove(key)) {
          modified = true;
        }
      }
      return modified;
    }

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

    @Override
    public void forEach(Consumer<? super K> action) {
      cache.data.keySet().forEach(action);
    }

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

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

    @Override
    public @Nullable Object[] toArray() {
      return cache.data.keySet().toArray();
    }

    @Override
    public <T extends @Nullable Object> T[] toArray(T[] array) {
      return cache.data.keySet().toArray(array);
    }
  }

  /** An adapter to safely externalize the key iterator. */
  static final class KeyIterator<K> implements Iterator<K> {
    final UnboundedLocalCache<K, ?> cache;
    final Iterator<K> iterator;
    @Nullable K current;

    KeyIterator(UnboundedLocalCache<K, ?> cache) {
      this.iterator = cache.data.keySet().iterator();
      this.cache = cache;
    }

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

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

    @Override
    @SuppressWarnings("ResultOfMethodCallIgnored")
    public void remove() {
      if (current == null) {
        throw new IllegalStateException();
      }
      cache.remove(current);
      current = null;
    }
  }

  /** An adapter to safely externalize the key spliterator. */
  static final class KeySpliterator<K> implements Spliterator<K> {
    final Spliterator<K> spliterator;

    KeySpliterator(UnboundedLocalCache<K, ?> cache) {
      this(cache.data.keySet().spliterator());
    }

    KeySpliterator(Spliterator<K> spliterator) {
      this.spliterator = requireNonNull(spliterator);
    }

    @Override
    public void forEachRemaining(Consumer<? super K> action) {
      requireNonNull(action);
      spliterator.forEachRemaining(action);
    }

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

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

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

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

  /** An adapter to safely externalize the values. */
  static final class ValuesView<K, V> extends AbstractCollection<V> {
    final UnboundedLocalCache<K, V> cache;

    ValuesView(UnboundedLocalCache<K, V> cache) {
      this.cache = requireNonNull(cache);
    }

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

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

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

    @Override
    @SuppressWarnings("SuspiciousMethodCalls")
    public boolean contains(@Nullable Object o) {
      return cache.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 : cache.data.entrySet()) {
        if (collection.contains(entry.getValue())
            && cache.remove(entry.getKey(), entry.getValue())) {
          modified = true;
        }
      }
      return modified;
    }

    @Override
    public boolean remove(@Nullable Object o) {
      if (o == null) {
        return false;
      }
      for (var entry : cache.data.entrySet()) {
        if (o.equals(entry.getValue()) && cache.remove(entry.getKey(), entry.getValue())) {
          return true;
        }
      }
      return false;
    }

    @Override
    public boolean removeIf(Predicate<? super V> filter) {
      requireNonNull(filter);
      @Var boolean removed = false;
      for (var entry : cache.data.entrySet()) {
        if (filter.test(entry.getValue())) {
          removed |= cache.remove(entry.getKey(), entry.getValue());
        }
      }
      return removed;
    }

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

    @Override
    public void forEach(Consumer<? super V> action) {
      cache.data.values().forEach(action);
    }

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

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

    @Override
    public @Nullable Object[] toArray() {
      return cache.data.values().toArray();
    }

    @Override
    public <T extends @Nullable Object> T[] toArray(T[] array) {
      return cache.data.values().toArray(array);
    }
  }

  /** An adapter to safely externalize the value iterator. */
  static final class ValueIterator<K, V> implements Iterator<V> {
    final UnboundedLocalCache<K, V> cache;
    final Iterator<Entry<K, V>> iterator;
    @Nullable Entry<K, V> entry;

    ValueIterator(UnboundedLocalCache<K, V> cache) {
      this.iterator = cache.data.entrySet().iterator();
      this.cache = cache;
    }

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

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

    @Override
    @SuppressWarnings("ResultOfMethodCallIgnored")
    public void remove() {
      if (entry == null) {
        throw new IllegalStateException();
      }
      cache.remove(entry.getKey());
      entry = null;
    }
  }

  /** An adapter to safely externalize the value spliterator. */
  static final class ValueSpliterator<V> implements Spliterator<V> {
    final Spliterator<V> spliterator;

    ValueSpliterator(UnboundedLocalCache<?, V> cache) {
      this(cache.data.values().spliterator());
    }

    ValueSpliterator(Spliterator<V> spliterator) {
      this.spliterator = requireNonNull(spliterator);
    }

    @Override
    public void forEachRemaining(Consumer<? super V> action) {
      requireNonNull(action);
      spliterator.forEachRemaining(action);
    }

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

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

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

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

  /** An adapter to safely externalize the entries. */
  static final class EntrySetView<K, V> extends AbstractSet<Entry<K, V>> {
    final UnboundedLocalCache<K, V> cache;

    EntrySetView(UnboundedLocalCache<K, V> cache) {
      this.cache = requireNonNull(cache);
    }

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

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

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

    @Override
    @SuppressWarnings("SuspiciousMethodCalls")
    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 = cache.get(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 ((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
    @SuppressWarnings("SuspiciousMethodCalls")
    public boolean remove(@Nullable Object o) {
      if (!(o instanceof Entry<?, ?>)) {
        return false;
      }
      var entry = (Entry<?, ?>) o;
      var key = entry.getKey();
      return (key != null) && cache.remove(key, entry.getValue());
    }

    @Override
    public boolean removeIf(Predicate<? super Entry<K, V>> filter) {
      requireNonNull(filter);
      @Var boolean removed = false;
      for (var entry : cache.data.entrySet()) {
        var key = entry.getKey();
        var value = entry.getValue();
        if (filter.test(Map.entry(key, value))) {
          removed |= cache.remove(key, value);
        }
      }
      return removed;
    }

    @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<>(cache);
    }

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

  /** An adapter to safely externalize the entry iterator. */
  static final class EntryIterator<K, V> implements Iterator<Entry<K, V>> {
    final UnboundedLocalCache<K, V> cache;
    final Iterator<Entry<K, V>> iterator;
    @Nullable Entry<K, V> entry;

    EntryIterator(UnboundedLocalCache<K, V> cache) {
      this.iterator = cache.data.entrySet().iterator();
      this.cache = cache;
    }

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

    @Override
    public Entry<K, V> next() {
      entry = iterator.next();
      return new WriteThroughEntry<>(cache, entry.getKey(), entry.getValue());
    }

    @Override
    @SuppressWarnings("ResultOfMethodCallIgnored")
    public void remove() {
      if (entry == null) {
        throw new IllegalStateException();
      }
      cache.remove(entry.getKey());
      entry = null;
    }
  }

  /** An adapter to safely externalize the entry spliterator. */
  static final class EntrySpliterator<K, V> implements Spliterator<Entry<K, V>> {
    final Spliterator<Entry<K, V>> spliterator;
    final UnboundedLocalCache<K, V> cache;

    EntrySpliterator(UnboundedLocalCache<K, V> cache) {
      this(cache, cache.data.entrySet().spliterator());
    }

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

    @Override
    public void forEachRemaining(Consumer<? super Entry<K, V>> action) {
      requireNonNull(action);
      spliterator.forEachRemaining(entry -> {
        var e = new WriteThroughEntry<>(cache, entry.getKey(), entry.getValue());
        action.accept(e);
      });
    }

    @Override
    public boolean tryAdvance(Consumer<? super Entry<K, V>> action) {
      requireNonNull(action);
      return spliterator.tryAdvance(entry -> {
        var e = new WriteThroughEntry<>(cache, entry.getKey(), entry.getValue());
        action.accept(e);
      });
    }

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

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

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

  /* --------------- Manual Cache --------------- */

  static class UnboundedLocalManualCache<K, V> implements LocalManualCache<K, V>, Serializable {
    private static final long serialVersionUID = 1;

    final UnboundedLocalCache<K, V> cache;
    @Nullable Policy<K, V> policy;

    UnboundedLocalManualCache(Caffeine<K, V> builder) {
      cache = new UnboundedLocalCache<>(builder, /* isAsync= */ false);
    }

    @Override
    public final UnboundedLocalCache<K, V> cache() {
      return cache;
    }

    @Override
    public final Policy<K, V> policy() {
      @Var var p = policy;
      if (p == null) {
        Function<@Nullable V, @Nullable V> identity = v -> v;
        p = new UnboundedPolicy<>(cache, identity);
        policy = p;
      }
      return p;
    }

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

    Object writeReplace() {
      var proxy = new SerializationProxy<K, V>();
      proxy.isRecordingStats = cache.isRecordingStats;
      proxy.removalListener = cache.removalListener;
      return proxy;
    }
  }

  /** An eviction policy that supports no bounding. */
  static final class UnboundedPolicy<K, V> implements Policy<K, V> {
    final Function<@Nullable V, @Nullable V> transformer;
    final UnboundedLocalCache<K, V> cache;

    UnboundedPolicy(UnboundedLocalCache<K, V> cache,
        Function<@Nullable V, @Nullable V> transformer) {
      this.transformer = transformer;
      this.cache = cache;
    }
    @Override public boolean isRecordingStats() {
      return cache.isRecordingStats;
    }
    @Override public @Nullable V getIfPresentQuietly(K key) {
      return transformer.apply(cache.data.get(key));
    }
    @Override public @Nullable CacheEntry<K, V> getEntryIfPresentQuietly(K key) {
      V value = transformer.apply(cache.data.get(key));
      return (value == null) ? null : SnapshotEntry.forEntry(key, value);
    }
    @SuppressWarnings("Java9CollectionFactory")
    @Override public Map<K, CompletableFuture<V>> refreshes() {
      var refreshes = cache.refreshes;
      if ((refreshes == null) || refreshes.isEmpty()) {
        @SuppressWarnings({"ImmutableMapOf", "RedundantUnmodifiable"})
        Map<K, CompletableFuture<V>> emptyMap = Collections.unmodifiableMap(Collections.emptyMap());
        return emptyMap;
      }
      @SuppressWarnings("unchecked")
      var castedRefreshes = (Map<K, CompletableFuture<V>>) (Object) refreshes;
      var inFlight = new HashMap<>(castedRefreshes);
      inFlight.values().removeIf(LocalLoadingCache.PendingRefresh.class::isInstance);
      return Collections.unmodifiableMap(inFlight);
    }
    @Override public Optional<Eviction<K, V>> eviction() {
      return Optional.empty();
    }
    @Override public Optional<FixedExpiration<K, V>> expireAfterAccess() {
      return Optional.empty();
    }
    @Override public Optional<FixedExpiration<K, V>> expireAfterWrite() {
      return Optional.empty();
    }
    @Override public Optional<VarExpiration<K, V>> expireVariably() {
      return Optional.empty();
    }
    @Override public Optional<FixedRefresh<K, V>> refreshAfterWrite() {
      return Optional.empty();
    }
  }

  /* --------------- Loading Cache --------------- */

  static final class UnboundedLocalLoadingCache<K, V> extends UnboundedLocalManualCache<K, V>
      implements LocalLoadingCache<K, V> {
    private static final long serialVersionUID = 1;

    final Function<K, @Nullable V> mappingFunction;
    final CacheLoader<? super K, V> cacheLoader;
    final @Nullable Function<Set<? extends K>, Map<K, V>> bulkMappingFunction;

    UnboundedLocalLoadingCache(Caffeine<K, V> builder, CacheLoader<? super K, V> cacheLoader) {
      super(builder);
      this.cacheLoader = cacheLoader;
      this.mappingFunction = newMappingFunction(cacheLoader);
      this.bulkMappingFunction = newBulkMappingFunction(cacheLoader);
    }

    @Override
    public AsyncCacheLoader<? super K, V> cacheLoader() {
      return cacheLoader;
    }

    @Override
    public Function<K, @Nullable V> mappingFunction() {
      return mappingFunction;
    }

    @Override
    public @Nullable Function<Set<? extends K>, Map<K, V>>  bulkMappingFunction() {
      return bulkMappingFunction;
    }

    @Override
    Object writeReplace() {
      @SuppressWarnings("unchecked")
      var proxy = (SerializationProxy<K, V>) super.writeReplace();
      proxy.cacheLoader = cacheLoader;
      return proxy;
    }

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

  /* --------------- Async Cache --------------- */

  static final class UnboundedLocalAsyncCache<K, V> implements LocalAsyncCache<K, V>, Serializable {
    private static final long serialVersionUID = 1;

    final UnboundedLocalCache<K, CompletableFuture<V>> cache;

    @Nullable ConcurrentMap<K, CompletableFuture<V>> mapView;
    @Nullable CacheView<K, V> cacheView;
    @Nullable Policy<K, V> policy;

    @SuppressWarnings("unchecked")
    UnboundedLocalAsyncCache(Caffeine<K, V> builder) {
      cache = new UnboundedLocalCache<>(
          (Caffeine<K, CompletableFuture<V>>) builder, /* isAsync= */ true);
    }

    @Override
    public UnboundedLocalCache<K, CompletableFuture<V>> cache() {
      return cache;
    }

    @Override
    public ConcurrentMap<K, CompletableFuture<V>> asMap() {
      var mv = mapView;
      return (mv == null) ? (mapView = new AsyncAsMapView<>(this)) : mv;
    }

    @Override
    public Cache<K, V> synchronous() {
      var cv = cacheView;
      return (cv == null) ? (cacheView = new CacheView<>(this)) : cv;
    }

    @Override
    public Policy<K, V> policy() {
      @SuppressWarnings("unchecked")
      var castCache = (UnboundedLocalCache<K, V>) cache;
      Function<CompletableFuture<V>, @Nullable V> transformer = Async::getIfReady;
      @SuppressWarnings("unchecked")
      var castTransformer = (Function<@Nullable V, @Nullable V>) transformer;
      var p = policy;
      return (p == null)
          ? (policy = new UnboundedPolicy<>(castCache, castTransformer))
          : p;
    }

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

    Object writeReplace() {
      var proxy = new SerializationProxy<K, V>();
      proxy.isRecordingStats = cache.isRecordingStats;
      proxy.removalListener = cache.removalListener;
      proxy.async = true;
      return proxy;
    }
  }

  /* --------------- Async Loading Cache --------------- */

  static final class UnboundedLocalAsyncLoadingCache<K, V>
      extends LocalAsyncLoadingCache<K, V> implements Serializable {
    private static final long serialVersionUID = 1;

    final UnboundedLocalCache<K, CompletableFuture<V>> cache;

    @Nullable ConcurrentMap<K, CompletableFuture<V>> mapView;
    @Nullable Policy<K, V> policy;

    @SuppressWarnings("unchecked")
    UnboundedLocalAsyncLoadingCache(Caffeine<K, V> builder, AsyncCacheLoader<? super K, V> loader) {
      super(loader);
      cache = new UnboundedLocalCache<>(
          (Caffeine<K, CompletableFuture<V>>) builder, /* isAsync= */ true);
    }

    @Override
    public LocalCache<K, CompletableFuture<V>> cache() {
      return cache;
    }

    @Override
    public ConcurrentMap<K, CompletableFuture<V>> asMap() {
      var mv = mapView;
      return (mv == null) ? (mapView = new AsyncAsMapView<>(this)) : mv;
    }

    @Override
    public Policy<K, V> policy() {
      @SuppressWarnings("unchecked")
      var castCache = (UnboundedLocalCache<K, V>) cache;
      Function<CompletableFuture<V>, @Nullable V> transformer = Async::getIfReady;
      @SuppressWarnings("unchecked")
      var castTransformer = (Function<@Nullable V, @Nullable V>) transformer;
      var p = policy;
      return (p == null)
          ? (policy = new UnboundedPolicy<>(castCache, castTransformer))
          : p;
    }

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

    Object writeReplace() {
      var proxy = new SerializationProxy<K, V>();
      proxy.isRecordingStats = cache.isRecordingStats();
      proxy.removalListener = cache.removalListener;
      proxy.cacheLoader = cacheLoader;
      proxy.async = true;
      return proxy;
    }
  }
}

ben-manes / caffeine / #5834

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