* @return the value returned by the factory
     */
    public abstract <V> V guardByKey(T key, Supplier<V> supplier);

    private static class AdaptiveProducerGuard<T> extends ProducerGuard<T> {
        private final Set<T> producing = new HashSet<>();

        @Override
        public <V> V guardByKey(T key, Supplier<V> supplier) {
            synchronized (producing) {
                while (!producing.add(key)) {

    def "calls all factories"() {
        given:
        def calls = new AtomicInteger()

        when:
        async {
            100.times {
                start {
                    guard.guardByKey("foo", new Supplier() {
                        @Override
                        Object get() {
                            return calls.getAndIncrement()
                        }
                    })

        // but multiple threads in this process could still try to extract into the same directory.
        cache.withFileLock(() -> {
            // guardByKey prevents multiple threads in this process from extracting into the same directory at the same time.
            guard.guardByKey(expandedDir, () -> {
                action.run();
                return null;
            });
        });
    }

    @Override

                    case Directory:
                        return Optional.empty();
                    case RegularFile:
                        return Optional.of(producingSnapshots.guardByKey(location,
                            () -> virtualFileSystem.findSnapshot(location)
                                .orElseGet(() -> {

        return refreshKeys || elapsed > MISSING_KEY_TIMEOUT;
    }

    @Override
    public void findByLongId(long keyId, PublicKeyResultBuilder builder) {
        longIdGuard.guardByKey(keyId, () -> {
            CacheEntry<List<Fingerprint>> fingerprints = longIdToFingerprint.getIfPresent(keyId);
            if (fingerprints == null || hasExpired(fingerprints)) {

    @Nullable
    @Override
    public File selectVersion(final ModuleComponentSelector selector, final VersionControlRepositoryConnection repository) {
        // Perform the work per repository
        return perRepoGuard.guardByKey(repository.getUniqueId(), new Supplier<File>() {
            @Nullable
            @Override
            public File get() {

            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    @Override
    public V get(final K key, final Function<? super K, ? extends V> producer) {
        return producerGuard.guardByKey(key, () -> {
            if (!entries.containsKey(key)) {
                put(key, producer.apply(key));
            }
            return TestInMemoryIndexedCache.this.getIfPresent(key);
        });
    }

        return producerGuard.guardByKey(location, () -> {
            LOGGER.debug("Constructing external resource: {}", location);
            CachedExternalResource cached = cachedExternalResourceIndex.lookup(location.toString());

    final fileRepository = Mock(FileResourceRepository)
    final cachePolicy = new DefaultExternalResourceCachePolicy()
    final ProducerGuard<URI> producerGuard = Stub() {
        guardByKey(_, _) >> { args ->
            def (key, supplier) = args
            supplier.get()
        }
    }