q.Lock()
	defer q.Unlock()
	worker, found := q.workers[key]
	result := false
	if found {
		logger.V(4).Info("Cancelling TimedWorkerQueue item", "item", key, "time", time.Now())
		if worker != nil {
			result = true
			worker.Cancel()
		}
		delete(q.workers, key)
	}
	return result
}

default   details-v1-698d88b-krdw7       10.244.2.55 ambient-worker2 None     HBONE
default   httpbin-7447985f87-t8hv7       10.244.1.40 ambient-worker  None     TCP
default   productpage-v1-675fc69cf-kkrm2 10.244.2.56 ambient-worker2 None     HBONE
default   ratings-v1-6484c4d9bb-8xc2r    10.244.2.57 ambient-worker2 None     HBONE
default   reviews-v1-5b5d6494f4-c7z5w    10.244.1.41 ambient-worker  None     HBONE

 */
public class WorkerConfig {
    private final LogLevel logLevel;
    private final boolean publishJvmMemoryInfo;
    private final String gradleUserHomeDirPath;
    private final MultiChoiceAddress serverAddress;
    private final long workerId;
    private final String displayName;
    private final Action<? super WorkerProcessContext> workerAction;

import org.gradle.workers.WorkAction;
import org.gradle.workers.internal.ActionExecutionSpecFactory;
import org.gradle.workers.internal.BuildOperationAwareWorker;
import org.gradle.workers.internal.DaemonForkOptions;
import org.gradle.workers.internal.DefaultWorkResult;
import org.gradle.workers.internal.IsolatedClassLoaderWorkerRequirement;
import org.gradle.workers.internal.ProvidesWorkResult;

import org.gradle.internal.isolated.IsolationScheme;
import org.gradle.internal.service.ServiceRegistry;
import org.gradle.process.internal.worker.RequestHandler;
import org.gradle.workers.WorkAction;
import org.gradle.workers.WorkParameters;

import javax.annotation.Nullable;

import static org.gradle.internal.classloader.ClassLoaderUtils.executeInClassloader;

        args("--info")
        succeeds "compileJava", "runInWorker"

        then:
        sinceSnapshot().count("Started Gradle worker daemon") == 2
        sinceSnapshot().contains("Stopped 1 worker daemon(s).")
    }

    @Requires(UnitTestPreconditions.Unix)
    def "worker daemons exit after the build is complete"() {
        fixture.withWorkActionClassInBuildScript()
        buildFile << """

 */

package org.gradle.workers.internal;

import java.io.File;

/**
 * Represents the directories a worker needs to understand in order to execute.
 *
 * TODO: This, and its subclasses, should probably be renamed to indicate that it is only about directories (for now)
 */
public interface WorkerRequirement {
    /**
     * Returns the directory in which to execute new workers.
     *

                
                java.util.logging.Logger.getLogger("worker").warning("jul warn");
                java.util.logging.Logger.getLogger("worker").warning("jul info");
                java.util.logging.Logger.getLogger("worker").fine("jul debug message");
                java.util.logging.Logger.getLogger("worker").severe("jul error");
                
                System.out.println("stdout message");

 * limitations under the License.
 */

package org.gradle.workers.internal

import spock.lang.Issue

class WorkerExecutorCompositeBuildIntegrationTest extends AbstractWorkerExecutorIntegrationTest {
    def plugin = testDirectory.createDir("plugin")
    def lib = testDirectory.createDir("lib")

    @Issue("https://github.com/gradle/gradle/issues/10317")
    def "can use worker api with composite builds using #pluginId"() {

import org.gradle.internal.jvm.Jvm
import org.gradle.test.precondition.TestPrecondition
import org.gradle.test.preconditions.UnitTestPreconditions
import org.gradle.workers.fixtures.OptionsVerifier
import org.gradle.workers.fixtures.WorkerExecutorFixture
import org.junit.Assume

import static org.gradle.api.internal.file.TestFiles.systemSpecificAbsolutePath