* it must be synchronized externally.
 * </p>
 * <p>
 * For thread-safe usage, wrap with {@link java.util.Collections#synchronizedMap(Map)}:
 * </p>
 * <pre>
 * Map&lt;K, V&gt; syncMap = Collections.synchronizedMap(new LruHashMap&lt;&gt;(100));
 * </pre>
 * <p>
 * Alternatively, for high-concurrency scenarios, consider implementing a custom

    return new SynchronizedMap<>(map, mutex);
  }

  private static class SynchronizedMap<K extends @Nullable Object, V extends @Nullable Object>
      extends SynchronizedObject implements Map<K, V> {
    transient @Nullable Set<K> keySet;
    transient @Nullable Collection<V> values;
    transient @Nullable Set<Map.Entry<K, V>> entrySet;

    SynchronizedMap(Map<K, V> delegate, @Nullable Object mutex) {

  }

  @VisibleForTesting
  static <K extends @Nullable Object, V extends @Nullable Object> Map<K, V> map(
      Map<K, V> map, @Nullable Object mutex) {
    return new SynchronizedMap<>(map, mutex);
  }

  private static class SynchronizedMap<K extends @Nullable Object, V extends @Nullable Object>
      extends SynchronizedObject implements Map<K, V> {
    transient @Nullable Set<K> keySet;

import java.net.UnknownHostException
import java.util.Collections
import okio.Buffer

class FakeDns : Dns {
  private val hostAddresses: MutableMap<String, List<InetAddress>> =
    Collections.synchronizedMap(mutableMapOf())
  private val requestedHosts: MutableList<String> = Collections.synchronizedList(mutableListOf())
  private var nextAddress = 0xff000064L // 255.0.0.100 in IPv4; ::ff00:64 in IPv6.

    private DependencyResolutionResult dependencyResolutionResult;

    private final List<Throwable> exceptions = new CopyOnWriteArrayList<>();

    private final Map<MavenProject, BuildSummary> buildSummaries = Collections.synchronizedMap(new IdentityHashMap<>());

    private boolean canResume = false;

    @Override
    public MavenExecutionResult setProject(MavenProject project) {
        this.project = project;

        return this;

 */
@Deprecated
public class ConsoleMavenTransferListener extends AbstractMavenTransferListener {

    private final Map<TransferResourceIdentifier, TransferResourceAndSize> transfers =
            Collections.synchronizedMap(new LinkedHashMap<TransferResourceIdentifier, TransferResourceAndSize>());

    private final boolean printResourceNames;
    private int lastLength;

 * Construct a version range from a specification.
 *
 */
public class VersionRange {
    private static final Map<String, VersionRange> CACHE_SPEC = Collections.synchronizedMap(new WeakHashMap<>());

    private static final Map<String, VersionRange> CACHE_VERSION = Collections.synchronizedMap(new WeakHashMap<>());

    private final ArtifactVersion recommendedVersion;

    private final List<Restriction> restrictions;

        return unmodifiableMap(Hash.create(keys));
      }
    },
    SyncHM {
      @Override
      Map<Element, Element> create(Collection<Element> keys) {
        return Collections.synchronizedMap(Hash.create(keys));
      }
    },
    Tree {
      @Override
      Map<Element, Element> create(Collection<Element> keys) {
        Map<Element, Element> map = Maps.newTreeMap();

    /**
     * Synchronized LRU cache for storing parent URL encodings.
     * Maps session+parent URL keys to their corresponding character encodings.
     */
    Map<String, String> parentEncodingMap = Collections.synchronizedMap(new LruHashMap<>(1000));

    /**
     * Gets the Fess configuration instance.
     *
     * @return the Fess configuration object
     */
    FessConfig getFessConfig();

    /**

     * @param value the parameter value to store
     */
    public synchronized void putToInfoMap(final String key, final String value) {
        if (infoMap == null) {
            infoMap = Collections.synchronizedMap(new LinkedHashMap<>());
        }
        logger.debug("infoMap: {}={} => {}", key, value, infoMap);
        infoMap.put(key, value);
    }

    /**