try {
                    if (initAction.requiresInitialization(fileLock)) {
                        fileLock.writeFile(() -> initAction.initialize(fileLock));
                    }
                    onOpen.accept(fileLock);
                } catch (Exception e) {
                    fileLock.close();
                    fileLock = null;
                    throw UncheckedException.throwAsUncheckedException(e);

     * The lock is not released between calling {@link #requiresInitialization(FileLock)} and this method.
     */
    void initialize(FileLock fileLock);

    CacheInitializationAction NO_INIT_REQUIRED = new CacheInitializationAction() {
        @Override
        public boolean requiresInitialization(FileLock fileLock) {
            return false;
        }

        @Override

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

package org.gradle.cache.internal

import org.gradle.cache.FileLock
import org.gradle.cache.FileLockManager
import org.gradle.cache.internal.filelock.DefaultLockOptions
import org.gradle.test.fixtures.file.TestFile
import spock.lang.Specification

import java.util.function.Consumer

    }

    /**
     * Called just after the file lock has been acquired.
     */
    private void afterLockAcquire(FileLock fileLock) {
        assert this.fileLock == null;
        this.fileLock = fileLock;
        this.stateAtOpen = fileLock.getState();

        withOwnershipNow(() -> {
            for (IndexedCacheEntry<?, ?> entry : caches.values()) {

 * limitations under the License.
 */

package org.gradle.cache.internal

import org.gradle.cache.FileLock
import org.gradle.cache.FileLockManager
import org.gradle.cache.FileLockReleasedSignal
import org.gradle.cache.LockOptions
import org.gradle.cache.internal.filelock.DefaultLockOptions
import org.gradle.test.fixtures.concurrent.ConcurrentSpec
import org.gradle.test.fixtures.file.TestFile

            def count = 0

            boolean requiresInitialization(FileLock fileLock) {
                assert fileLock != null
                count++
                println "Checking initialized $count"
                return count < 4
            }

            void initialize(FileLock fileLock) {}
        }
        def lockOptions = DefaultLockOptions.mode(FileLockManager.LockMode.Shared)

    private final Cache<Object, Object> inMemoryCache;
    private final String cacheId;
    private final AtomicReference<FileLock.State> fileLockStateReference;

    public InMemoryDecoratedCache(MultiProcessSafeAsyncPersistentIndexedCache<K, V> delegate, Cache<Object, Object> inMemoryCache, String cacheId, AtomicReference<FileLock.State> fileLockStateReference) {
        this.delegate = delegate;
        this.inMemoryCache = inMemoryCache;

	prevStack := "x"
	for pc := pc1; pc < pc1+1024 && findfunc(pc) == f; pc += sys.PCQuantum {
		stack := ""
		u, uf := newInlineUnwinder(f, pc)
		if file, _ := u.fileLine(uf); file == "?" {
			// We're probably in the trailing function padding, where findfunc
			// still returns f but there's no symbolic information. Just keep
			// going until we definitely hit the end. If we see a "?" in the

        try {
            FileLock fileLock = lockFileAccess.getChannel().tryLock(infoRegionPos, INFORMATION_REGION_SIZE - infoRegionPos, shared);
            if (fileLock == null) {
                return FileLockOutcome.LOCKED_BY_ANOTHER_PROCESS;
            } else {
                return FileLockOutcome.acquired(fileLock);
            }
        } catch (OverlappingFileLockException e) {

        try {
            FileLock fileLock = lockFileAccess.getChannel().tryLock(REGION_START, stateRegionSize, shared);
            if (fileLock == null) {
                return FileLockOutcome.LOCKED_BY_ANOTHER_PROCESS;
            } else {
                return FileLockOutcome.acquired(fileLock);
            }
        } catch (OverlappingFileLockException e) {