import java.util.concurrent.ConcurrentMap;

public abstract class AbstractResourceLockRegistry<K, T extends ResourceLock> implements ResourceLockRegistry, ResourceLockContainer {
    private final LockCache<K, T> resourceLocks;
    private final ConcurrentMap<Long, ThreadLockDetails<T>> threadLocks = new ConcurrentHashMap<Long, ThreadLockDetails<T>>();

    public AbstractResourceLockRegistry(final ResourceLockCoordinationService coordinationService) {

    }

    static class TestRegistry extends AbstractResourceLockRegistry<String, ResourceLock> {
        TestRegistry(ResourceLockCoordinationService coordinationService) {
            super(coordinationService)
        }

        def getResourceLock(String displayName) {
            return getOrRegisterResourceLock(displayName, new AbstractResourceLockRegistry.ResourceLockProducer<String, ResourceLock>() {
                @Override

        this.coordinationService = coordinationService;
        this.owner = owner;
    }

    public T getOrRegisterResourceLock(final K key, final AbstractResourceLockRegistry.ResourceLockProducer<K, T> producer) {
        try {
            return resourceLocks.get(key, new Callable<T>() {
                @Override
                public T call() {

 * limitations under the License.
 */

package org.gradle.internal.resources;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class SharedResourceLeaseRegistry extends AbstractResourceLockRegistry<String, ResourceLock> {
    private final Map<String, LeaseHolder> sharedResources = new ConcurrentHashMap<String, LeaseHolder>();
    private final ResourceLockCoordinationService coordinationService;

 * limitations under the License.
 */

package org.gradle.internal.resources;

import org.gradle.util.Path;

public class TaskExecutionLockRegistry extends AbstractResourceLockRegistry<Path, TaskExecutionLock> {
    private final ProjectLockRegistry projectLockRegistry;

    public TaskExecutionLockRegistry(ResourceLockCoordinationService coordinationService, ProjectLockRegistry projectLockRegistry) {

 * limitations under the License.
 */

package org.gradle.internal.resources;

import org.gradle.util.Path;

public class ProjectLockRegistry extends AbstractResourceLockRegistry<Path, ProjectLock> {
    private final boolean parallelEnabled;
    private final LockCache<Path, AllProjectsLock> allProjectsLocks;

import org.gradle.internal.Factories;
import org.gradle.internal.Factory;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.concurrent.WorkerLimits;
import org.gradle.internal.resources.AbstractResourceLockRegistry;
import org.gradle.internal.resources.DefaultLease;
import org.gradle.internal.resources.DefaultResourceLockCoordinationService;
import org.gradle.internal.resources.LeaseHolder;

Class <org.gradle.internal.resources.AbstractResourceLockRegistry$ResourceLockProducer> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (AbstractResourceLockRegistry.java:0)
Class <org.gradle.internal.resources.AbstractResourceLockRegistry$ThreadLockDetails> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (AbstractResourceLockRegistry.java:0)