} else {
      statsCounter.recordEviction();
      statsCounter.recordMisses(1);
      // `key` was in the cache, so it's a K.
      // (Or it's a weird case like a LinkedList in a Cache<ArrayList, ...>, but *shrug*.)
      @SuppressWarnings("unchecked")
      K castKey = (K) key;
      alertListenerIfPresent(castKey, value.getValue(), RemovalCause.EXPIRED);
      cachingHashMap.remove(key);
      return null;
    }
  }

   * save that if that location is already full, we try the next index, and the next, until we
   * find an empty table position.  Since the table has a power-of-two size, we use
   * & (table.length - 1) instead of % table.length, though.
   */

  @CheckForNull private final transient Object hashTable;
  @VisibleForTesting final transient @Nullable Object[] alternatingKeysAndValues;
  private final transient int size;

  /*

        "Shouldn't catch any more events when unregistered.", expectedEvents, catcher2.getEvents());
  }

  // NOTE: This test will always pass if register() is thread-safe but may also
  // pass if it isn't, though this is unlikely.
  public void testRegisterThreadSafety() throws Exception {
    List<StringCatcher> catchers = Lists.newCopyOnWriteArrayList();
    List<Future<?>> futures = Lists.newArrayList();

        "Shouldn't catch any more events when unregistered.", expectedEvents, catcher2.getEvents());
  }

  // NOTE: This test will always pass if register() is thread-safe but may also
  // pass if it isn't, though this is unlikely.
  public void testRegisterThreadSafety() throws Exception {
    List<StringCatcher> catchers = Lists.newCopyOnWriteArrayList();
    List<Future<?>> futures = Lists.newArrayList();

  private static final class AvlNode<E extends @Nullable Object> {
    /*
     * For "normal" nodes, the type of this field is `E`, not `@Nullable E` (though note that E is a
     * type that can include null, as in a TreeMultiset<@Nullable String>).
     *
     * For the header node, though, this field contains `null`, regardless of the type of the
     * multiset.
     *

   *     neither fast nor secure. As of January 2017, we suggest:
   *     <ul>
   *       <li>For security:
   *           {@link Hashing#sha256} or a higher-level API.
   *       <li>For speed: {@link Hashing#goodFastHash}, though see its docs for caveats.
   *     </ul>
   */
  @Deprecated
  public static HashFunction md5() {
    return Md5Holder.MD5;
  }

  private static class Md5Holder {

         * the type parameter is <E>, since otherwise the
         * MultiExceptionListIterator wouldn't be an Iterator<E>. The cast is
         * safe, even though javac can't tell.
         *
         * Sun bug 6665356 is an additional complication. Until OpenJDK 7, javac
         * doesn't recognize this kind of cast as unchecked cast. Neither does

     * requireNonNull checks below). Plus, we're *already* lying here, since newHeader passes a null
     * key and value, which we pass to the superconstructor, even though the key and value type for
     * a given entry might not include null. The right fix for the header problems is probably to
     * define a separate MultimapLink interface with a separate "header" implementation, which

     * multimap and its {@link Multimap#asMap()} view are {@link ImmutableSortedSet} instances.
     * However, serialization does not preserve that property, though it does maintain the key and
     * value ordering.
     *
     * @since 8.0
     */
    // TODO: Make serialization behavior consistent.
    @CanIgnoreReturnValue
    @Override

  //
  // 2. Since you can enter the monitor without a guard at all, some
  //    places you'll have monitor.enter()/monitor.leave() and other
  //    places you'll have guard.enter()/guard.leave() even though
  //    it's the same lock being acquired underneath. Always using
  //    monitor.enterXXX()/monitor.leave() will make it really clear
  //    which lock is held at any point in the code.
  //