import org.gradle.internal.remote.internal.hub.protocol.EndOfStream;
import org.gradle.internal.remote.internal.hub.queue.MultiChannelQueue;

import java.util.concurrent.locks.Lock;

class IncomingQueue extends MultiChannelQueue {
    IncomingQueue(Lock lock) {
        super(lock);
    }

    public void requestStop() {
        queue(new EndOfStream());
    }

    /**
     * Possible results from a resource lock state transform.
     */
    enum Disposition { FAILED, FINISHED, RETRY }

    /**
     * Registers a resource lock to be rolled back if the transform associated with this resource lock state
     * fails.
     */
    void registerLocked(ResourceLock resourceLock);

    /**

### Locks

We have 3 different things that we synchronize on.

#### Http2Connection

This lock guards internal state of each connection. This lock is never held for blocking operations. That means that we acquire the lock, read or write a few fields and release the lock. No I/O and no application-layer callbacks.

#### Http2Stream

    public void loadLocally(HashCode key, Consumer<? super File> reader) {
        // We need to lock other processes out here because garbage collection can be under way in another process
        persistentCache.withFileLock(() -> {
            // Additional locking necessary because of https://github.com/gradle/gradle/issues/3537
            lock.readLock().lock();
            try {
                loadInsideLock(key, reader);
            } finally {

            inUseClassLoaders.add(cachedClassLoader);
        } finally {
            lock.unlock();
        }

        try {
            action.execute(cachedClassLoader);
        } finally {
            lock.lock();
            try {
                inUseClassLoaders.remove(cachedClassLoader);
            } finally {
                lock.unlock();
            }
        }
    }

	TimeLastRefresh time.Time // Timestamp for last lock refresh.
	Source          string    // Contains line, function and filename requesting the lock.
	Group           bool      // indicates if it was a group lock.
	Owner           string    // Owner represents the UUID of the owner who originally requested the lock.
	Quorum          int       // Quorum represents the quorum required for this lock to be active.

    private final AtomicBoolean stopped = new AtomicBoolean();

    // Protects the following fields
    private final Lock lock;
    private final Map<ClassPath, Cleanup> cleanups;
    private final Map<ClassPath, CacheEntry> cacheEntries;

    public FinalizerThread(Map<ClassPath, CacheEntry> cacheEntries, Lock lock) {
        this.setName("Classloader cache reference queue poller");
        this.setDaemon(true);

type fdMutex struct {
	state uint64
	rsema uint32
	wsema uint32
}

// fdMutex.state is organized as follows:
// 1 bit - whether FD is closed, if set all subsequent lock operations will fail.
// 1 bit - lock for read operations.
// 1 bit - lock for write operations.
// 20 bits - total number of references (read+write+misc).
// 20 bits - number of outstanding read waiters.
// 20 bits - number of outstanding write waiters.
const (

import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@ThreadSafe
public class ClasspathInferer {
    private static final Logger LOGGER = LoggerFactory.getLogger(ClasspathInferer.class);
    private final Lock lock = new ReentrantLock();
    private final Map<Class<?>, Collection<URI>> classPathCache;

	if err != nil {
		return nil, err
	}

	// Although the operating system will drop locks for open files when the go
	// command exits, we want to hold locks for as little time as possible, and we
	// especially don't want to leave a file locked after we're done with it. Our
	// Close method is what releases the locks, so use a finalizer to report
	// missing Close calls on a best-effort basis.