}
	}

	return nil
}

func (c *containerLogManager) processQueueItems(ctx context.Context, worker int) {
	klog.V(4).InfoS("Starting container log rotation worker", "workerID", worker)
	for c.processContainer(ctx, worker) {
	}
	klog.V(4).InfoS("Terminating container log rotation worker", "workerID", worker)
}

func (c *containerLogManager) rotateLogs(ctx context.Context) error {
	c.mutex.Lock()

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.process.internal.health.memory.OsMemoryInfo;
import org.gradle.process.internal.worker.WorkerJvmMemoryInfoSerializer;
import org.gradle.process.internal.worker.WorkerLoggingSerializer;
import org.gradle.process.internal.worker.WorkerProcessContext;
import org.gradle.process.internal.worker.messaging.WorkerConfig;
import org.gradle.process.internal.worker.messaging.WorkerConfigSerializer;

import java.io.DataInputStream;
import java.io.File;

            List<WorkerState> workers = allWorkers.get();
            if (workers == null || workers.isEmpty()) {
                // Workers have not been started yet, assume this is going to happen and that everything is healthy
                return null;
            }

            int waitingWorkers = 0;
            int stoppedWorkers = 0;
            for (WorkerState worker : workers) {

The Worker API can accommodate this using the `processIsolation()` method that causes the work to execute in a separate "worker daemon".
These worker processes will be session-scoped and can be reused within the same build session, but they won't persist across builds.
However, if system resources get low, Gradle will stop unused worker daemons.

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;

	// inputC is sent values to fuzz by the coordinator. Any worker may receive
	// values from this channel. Workers send results to resultC.
	inputC chan fuzzInput

	// minimizeC is sent values to minimize by the coordinator. Any worker may
	// receive values from this channel. Workers send results to resultC.
	minimizeC chan fuzzMinimizeInput

	// resultC is sent results of fuzzing by workers. The coordinator

        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");