def "can get a lock associated with the current thread"() {
        when:
        def lock = registry.getResourceLock("test")

        then:
        lock instanceof TestTrackedResourceLock

        when:
        lock.tryLock()

        then:
        registry.getResourceLocksByCurrentThread() == [lock]
    }

    def "does not get locks associated with other threads"() {
        when:

     *
     * Fails if the current thread is already holding the resource lock. May release project locks prior to blocking, as per {@link WorkerLeaseService#blocking(Runnable)}.
     */
    void withLock(Runnable action);

    /**
     * Runs the given action while holding the associated resource lock, blocking until the lock can be acquired.
     *

import org.gradle.tooling.internal.protocol.InternalBuildProgressListener;

import java.io.Closeable;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SynchronizedToolingImplementationLoader implements ToolingImplementationLoader, Closeable {
    private final Lock lock = new ReentrantLock();
    private final ToolingImplementationLoader delegate;

import javax.annotation.Nullable;
import javax.annotation.concurrent.ThreadSafe;
import java.util.UUID;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@ThreadSafe
@ServiceScope(Scope.Global.class)
public class ClassLoaderCache {
    private final Lock lock = new ReentrantLock();
    private final Cache<ClassLoader, ClassLoaderDetails> classLoaderDetails;

            // Doing so can lead to deadlocks.

            assertCanMutate();

            if (lock.tryLock()) {
                // Update lock was not contended, can keep holding the project locks
                return;
            }

        final Thread owner = Thread.currentThread()
        final ProjectInternal project
        boolean locked
        final Collection<MockLock> locks

        MockLock(ProjectInternal project, Collection<MockLock> locks) {
            this.locks = locks
            this.project = project
        }

        @Override
        boolean isLockedByCurrentThread() {

Klaus Post <******@****.***> 1700528975 -0800

import java.io.IOException;
import java.time.Duration;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

class SendPartialResponseThenBlock implements BlockingHttpServer.BlockingRequest, ResponseProducer {
    private final byte[] content;
    private final Lock lock;
    private final Duration timeout;
    private final Condition condition;

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

package org.gradle.internal.concurrent;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Wraps a runnable so that it can be interrupted. Useful when {@link java.util.concurrent.Future} is not available or its behavior is not desired.
 *

    }

    def "can use worker lease as resource lock"() {
        def registry = workerLeaseService(1)

        when:
        def workerLease = registry.newWorkerLease()
        coordinationService.withStateLock(lock(workerLease))

        then:
        noExceptionThrown()
    }

    def "acquire lease as resource lock blocks when there are no leases available"() {