package org.gradle.cache;

import java.util.Collection;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Function;

public class ManualEvictionInMemoryCache<K, V> implements Cache<K, V> {
    // Use 256 as initial size to start out with enough concurrency.
    private final ConcurrentMap<K, V> map = new ConcurrentHashMap<>(256);

    @Override

 * limitations under the License.
 */

package org.gradle.internal.execution.steps

import org.gradle.cache.Cache
import org.gradle.cache.ManualEvictionInMemoryCache
import org.gradle.caching.internal.origin.OriginMetadata
import org.gradle.internal.Try
import org.gradle.internal.execution.ExecutionEngine
import org.gradle.internal.execution.UnitOfWork

    def "supports #concurrency concurrent computations"() {
        def latch = new CountDownLatch(concurrency)
        def executor = Executors.newFixedThreadPool(concurrency)
        def cache = new ManualEvictionInMemoryCache<String, String>()

        when:
        concurrency.times { idx ->
            executor.submit {
                String key = "key${idx}"
                cache.get(key, {