private DependencyResolutionResult dependencyResolutionResult;

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

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

    private boolean canResume = false;

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

        return this;
    }

public class CachingJvmMetadataDetector implements JvmMetadataDetector, ConditionalInvalidation<JvmInstallationMetadata> {

    private final Map<File, JvmInstallationMetadata> javaMetadata = Collections.synchronizedMap(new HashMap<>());
    private final JvmMetadataDetector delegate;

    public CachingJvmMetadataDetector(JvmMetadataDetector delegate) {
        this.delegate = delegate;

import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;

@NonNullApi
public class CallInterceptorRegistry {
    private static final Map<ClassLoader, Boolean> LOADED_FROM_CLASSLOADERS = Collections.synchronizedMap(new WeakHashMap<>());
    private static volatile Map<BytecodeInterceptorFilter, CallSiteDecorator> groovyDecorators = new ConcurrentHashMap<>();

     * the map must be protected from concurrent modification.
     */
    final Map<Pair<File, String>, IndexedCache<?, ?>> caches = Collections.synchronizedMap(new LinkedHashMap<>());

    @Override

public class DefaultHashingClassLoaderFactory extends DefaultClassLoaderFactory implements HashingClassLoaderFactory {
    private final ClasspathHasher classpathHasher;
    private final Map<ClassLoader, HashCode> hashCodes = Collections.synchronizedMap(new WeakHashMap<ClassLoader, HashCode>());

    public DefaultHashingClassLoaderFactory(ClasspathHasher classpathHasher) {
        this.classpathHasher = classpathHasher;
    }

    @Override

            Collections.synchronizedMap(new WeakHashMap<>());
    private final Map<org.eclipse.aether.artifact.Artifact, Artifact> allArtifacts =
            Collections.synchronizedMap(new WeakHashMap<>());
    private final Map<org.eclipse.aether.repository.RemoteRepository, RemoteRepository> allRepositories =
            Collections.synchronizedMap(new WeakHashMap<>());

 * 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;

  }

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

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

  }

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

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

import org.codelibs.fess.mylasta.direction.FessConfig;
import org.codelibs.fess.util.ComponentUtil;

public interface FessTransformer {

    Map<String, String> parentEncodingMap = Collections.synchronizedMap(new LruHashMap<>(1000));

    FessConfig getFessConfig();

    Logger getLogger();

    default String getHost(final String u) {
        if (StringUtil.isBlank(u)) {