ConcurrentHashMap<Object, Supplier<?>> cache;
        RepositoryCache repositoryCache = session != null ? session.getCache() : null;
        if (repositoryCache == null) {
            return new DefaultModelCache(new ConcurrentHashMap<>());
        } else {
            if (anew) {
                cache = new ConcurrentHashMap<>();
                repositoryCache.put(session, KEY, cache);

        val rootProjectDir: DirectoryProperty
    }

    @get:Inject
    abstract val execOperations: ExecOperations

    private
    val suspiciousDaemons = ConcurrentHashMap<String, MutableSet<String>>()

    private
    val daemonPids = ConcurrentHashMap.newKeySet<String>()

    private
    val logger = Logging.getLogger(DaemonTracker::class.java)

    override fun close() {

    final ModelProcessor modelLocator;

    final Map<String, String> userProperties = new ConcurrentHashMap<>();

    final Map<Path, Holder> modelByPath = new ConcurrentHashMap<>();

    final Map<GAKey, Holder> modelByGA = new ConcurrentHashMap<>();

    public static class Holder {
        private volatile boolean set;
        private volatile Model model;

        Holder() {}

    private final TypeRegistry typeRegistry;

    private final ConcurrentHashMap<String, ArtifactHandler> allHandlers;

    @Inject
    public DefaultArtifactHandlerManager(TypeRegistry typeRegistry) {
        this.typeRegistry = requireNonNull(typeRegistry, "null typeRegistry");
        this.allHandlers = new ConcurrentHashMap<>();
    }

    @Override
    public void onEvent(Object event) {

import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.maven.api.model.Model;

/**
 * Holds all Models that are known to the reactor. This allows the project builder to resolve imported Models from the
 * reactor when building another project's effective model.
 *
 */
class ReactorModelPool {
    private final Map<GAKey, Set<Model>> modelsByGa = new ConcurrentHashMap<>();

 *
 * @since 3.0
 */
@Named
@Singleton
public class DefaultPluginDescriptorCache implements PluginDescriptorCache {

    private Map<Key, PluginDescriptor> descriptors = new ConcurrentHashMap<>(128);
    private Map<Key, Key> keys = new ConcurrentHashMap<>();

    public void flush() {
        descriptors.clear();
    }

    public Key createKey(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session) {

  private static final String TEST_KEY = "test key";
  private static final String TEST_VALUE = "test value";

  // Non-loading versions:
  private final Map<Object, Object> map = new MapMaker().makeMap(); // Returns ConcurrentHashMap
  private final Cache<Object, Object> cache = CacheBuilder.newBuilder().recordStats().build();
  private final Cache<Object, Object> cacheNoStats = CacheBuilder.newBuilder().build();

  @BeforeExperiment
  void setUp() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.collect;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import junit.framework.TestCase;

/**
 * Tests for {@link ForwardingConcurrentMap}.
 *
 * @author Jared Levy
 */

 * existing multiset values.
 *
 * @author mike nonemacher
 */

public class ConcurrentHashMultisetBasherTest extends TestCase {

  public void testAddAndRemove_ConcurrentHashMap() throws Exception {
    testAddAndRemove(new ConcurrentHashMap<String, AtomicInteger>());
  }

  public void testAddAndRemove_ConcurrentSkipListMap() throws Exception {
    testAddAndRemove(new ConcurrentSkipListMap<String, AtomicInteger>());
  }

    }

    /**
     * 指定されたキーと値を持つ{@link ConcurrentHashMap}を構築するための{@literal Maps}を返します。
     *
     * @param <KEY>
     *            <code>Map</code>のキーの型
     * @param <VALUE>
     *            <code>Map</code>の値ーの型
     * @param key
     *            <code>Map</code>に追加されるキー
     * @param value
     *            <code>Map</code>に追加される値
     * @return 指定されたキーと値を持つ{@link ConcurrentHashMap}を構築するための{@literal Maps}
     */