* while it is in use. You can change this use {@link CacheBuilder#withInitialLockMode(org.gradle.cache.FileLockManager.LockMode)}.
 *
 * <p>You can use {@link CacheBuilder#withInitializer(java.util.function.Consumer)} to provide an action to initialize the contents

            // and move them atomically into the cache
            // TODO Should use a read-write lock on the cache's base directory for cleanup, though
            .withInitialLockMode(FileLockManager.LockMode.None)
            .open();
        this.cache = cache;
        this.baseDirectory = cache.getBaseDir();

                return count < 4
            }

            void initialize(FileLock fileLock) {}
        }
        def lockOptions = DefaultLockOptions.mode(FileLockManager.LockMode.Shared)
        def lockManager1 = DefaultFileLockManagerTestHelper.createDefaultFileLockManager(100)
        new FixedSharedModeCrossProcessCacheAccess("<cache>", cacheDir, lockOptions, lockManager1, countingInitAction, {}, {})

import org.gradle.internal.time.TimestampSuppliers;

import javax.inject.Inject;
import java.io.File;
import java.util.function.Supplier;

import static org.gradle.cache.FileLockManager.LockMode.OnDemand;

public class DirectoryBuildCacheServiceFactory implements BuildCacheServiceFactory<DirectoryBuildCache> {
    public static final String FAILED_READ_SUFFIX = ".failed";

        this.vcsWorkingDirCache = cacheBuilderFactory
            .createCrossVersionCacheBuilder("vcs-1")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .withDisplayName("VCS Checkout Cache")
            .withCleanupStrategy(createCacheCleanupStrategy())
            .open();
    }

    private CacheCleanupStrategy createCacheCleanupStrategy() {

        cache = unscopedCacheBuilderFactory
            .cache(cacheMetaData.getCacheDir())
            .withDisplayName("read only artifact cache")
            .withInitialLockMode(FileLockManager.LockMode.None) // Don't need to lock anything, it's read-only
            .open();
    }

    @Override
    public void close() {
        cache.close();
    }

    @Override

        cache = unscopedCacheBuilderFactory
                .cache(cacheMetaData.getCacheDir())
                .withDisplayName("artifact cache")
                .withInitialLockMode(FileLockManager.LockMode.OnDemand) // Don't need to lock anything until we use the caches
                .withCleanupStrategy(createCacheCleanupStrategy(cacheMetaData, fileAccessTimeJournal, usedGradleVersions, cacheConfigurations))
                .open();

    }

    private DefaultComponentMetadataProcessor processorWithCacheThatNeverHits() {
        CacheBuilder cacheBuilder
        cacheBuilder = Mock(CacheBuilder) {
            withInitialLockMode(_ as FileLockManager.LockMode) >> { cacheBuilder }
            open() >> {
                Mock(PersistentCache) {
                    createIndexedCache(_ as IndexedCacheParameters) >> {
                        Mock(IndexedCache) {

            .createCrossVersionCacheBuilder("buildOutputCleanup")
            .withDisplayName("Build Output Cleanup Cache")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .withProperties(Collections.singletonMap("gradle.version", GradleVersion.current().getVersion()))
            .open();

                    PersistentCache workerClassPathCache = cacheBuilderFactory
                        .createCacheBuilder("workerMain")
                        .withInitialLockMode(FileLockManager.LockMode.Exclusive)
                        .withInitializer(new CacheInitializer())
                        .open();
                    try {