}
		}
	}(ctx.Done())

	go func(stopCh <-chan struct{}) {
		for {
			podUpdate, shutdown := tc.podUpdateQueue.Get()
			if shutdown {
				break
			}
			// The fact that pods are processed by the same worker as nodes is used to avoid races
			// between node worker setting tc.taintedNodes and pod worker reading this to decide
			// whether to delete pod.

		}
		stillWorking := false

		// ignore held workers
		w.lock.Lock()
		for uid := range w.holds {
			pausedWorkers[uid] = struct{}{}
		}
		w.lock.Unlock()

		// check for at least one still working non-paused worker
		w.w.podLock.Lock()
		for uid, worker := range w.w.podSyncStatuses {
			if _, ok := pausedWorkers[uid]; ok {
				continue
			}
			if worker.working {
				stillWorking = true
				break

    @Requires(IntegTestPreconditions.NotEmbeddedExecutor)
    @UnsupportedWithConfigurationCache(because = "captures worker threads in shared state")
    def "task operations are closed even when interrupting the execution workers"() {
        server.start()
        executer.withStackTraceChecksDisabled()
        def parallelTaskCount = 5
        buildFile << """

        then:
        1 * clientsManager.reserveIdleClient(options) >> client
        1 * buildOperationRunner.call(_)
    }

    def "build worker operation is finished even if worker fails"() {
        when:
        factory.getWorker(requirement).execute(spec)

        then:
        1 * clientsManager.reserveIdleClient(options) >> client

 * limitations under the License.
 */

package org.gradle.workers;

import org.gradle.internal.exceptions.Contextual;
import org.gradle.internal.exceptions.DefaultMultiCauseException;

/**
 * Indicates that a failure occurred during execution of work in a worker.
 *
 * @since 3.5
 */
@Contextual
public class WorkerExecutionException extends DefaultMultiCauseException {

import org.gradle.process.internal.JavaForkOptionsFactory;
import org.gradle.process.internal.worker.child.WorkerDirectoryProvider;
import org.gradle.workers.internal.ActionExecutionSpecFactory;
import org.gradle.workers.internal.IsolatedClassloaderWorkerFactory;
import org.gradle.workers.internal.WorkerDaemonFactory;

import javax.inject.Inject;
import java.io.File;
import java.util.List;

					"ivy",
					"testing-native",
					"maven",
					"integ-test"
				]
			},
			{
				"parallelizationMethod":{
					"name":"TestDistribution"
				},
				"subprojects":[
					"workers",
					"model-core",
					"language-groovy",
					"build-init",
					"logging",
					"plugins-groovy",
					"kotlin-dsl",
					"plugins-java",
					"samples",
					"plugin-development",

            options.setDocTitle(getTitle());
        }

        WorkQueue queue = getWorkerExecutor().processIsolation(worker -> {
            worker.getClasspath().from(getScalaClasspath());
            JavaForkOptions forkOptions = worker.getForkOptions();
            if (getMaxMemory().isPresent()) {
                forkOptions.setMaxHeapSize(getMaxMemory().get());
            }

		return
	}

	for i := 0; i < workers; i++ {
		go wait.UntilWithContext(ctx, cc.worker, time.Second)
	}

	<-ctx.Done()
}

// worker runs a thread that dequeues CSRs, handles them, and marks them done.
func (cc *CertificateController) worker(ctx context.Context) {
	for cc.processNextWorkItem(ctx) {
	}
}

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

package org.gradle.workers;

import org.gradle.api.Action;
import org.gradle.process.JavaForkOptions;

/**
 * A worker spec providing the requirements of a forked process.
 *
 * @since 5.6
 */
public interface ForkingWorkerSpec extends WorkerSpec {
    /**