* However, the implementations:
 * <ul>
 * <li>should allow separate threads for dispatching and receiving, i.e. single thread that dispatches
 * and a different single thread that receives should be perfectly safe</li>
 * <li>should allow stopping or requesting stopping from a different thread than receiving/dispatching</li>
 * <li>don't guarantee allowing multiple threads dispatching</li>
 * </ul>
 */

/**
 * A specification that uses multiple test threads. Provides an {@link Executor} and {@link org.gradle.internal.concurrent.ExecutorFactory} implementation.
 *
 * <p>This class maintains a set of instants reached by the test. An instant records the point in time that a test thread reached a certain point of its execution.

     * Called just after the cache is locked. Called before any work is performed by other threads. This method may access the cache files.
     *
     * @param currentCacheState the current cache state.
     */
    void afterLockAcquire(FileLock.State currentCacheState);

    /**
     * Called when the cache is due to be unlocked. Call after other threads have completed work. This method may access the cache files.
     */
    void finishWork();

   * This is useful if the given service uses daemon threads, and we want to keep the JVM from
   * exiting immediately on shutdown, instead giving these daemon threads a chance to terminate
   * normally.
   *
   * @param service ExecutorService which uses daemon threads
   * @param terminationTimeout how long to wait for the executor to finish before terminating the
   *     JVM

                    // both threads are accessing project
                    instant.finished1
                    thread.blockUntil.mutating2
                    // both threads are accessing project
                    instant.finished2
                }
            }
        }

        then:
        noExceptionThrown()
    }

   * @param nameSupplier The supplier of thread names, {@link Supplier#get get} will be called once
   *     for each invocation of the wrapped callable.
   */
  @J2ktIncompatible
  @GwtIncompatible // threads
  static <T extends @Nullable Object> Callable<T> threadRenaming(
      Callable<T> callable, Supplier<String> nameSupplier) {
    checkNotNull(nameSupplier);
    checkNotNull(callable);
    return () -> {

            }
            if (parameters.incrementalAnalysis.get()) {
                PmdInvoker.assertUnsupportedIncrementalAnalysis(version)
            }
            antPmdArgs['threads'] = parameters.threads.get()
        } else {
            // 6.+
            if (parameters.incrementalAnalysis.get()) {
                antPmdArgs["cacheLocation"] = parameters.incrementalCacheFile.get().asFile

// or are locked to other goroutines due to use of runtime.LockOSThread.
//
// SetMaxThreads is useful mainly for limiting the damage done by
// programs that create an unbounded number of threads. The idea is
// to take down the program before it takes down the operating system.
func SetMaxThreads(threads int) int {
	return setMaxThreads(threads)
}

   * @param nameSupplier The supplier of thread names, {@link Supplier#get get} will be called once
   *     for each invocation of the wrapped callable.
   */
  @J2ktIncompatible
  @GwtIncompatible // threads
  static <T extends @Nullable Object> Callable<T> threadRenaming(
      Callable<T> callable, Supplier<String> nameSupplier) {
    checkNotNull(nameSupplier);
    checkNotNull(callable);
    return () -> {

        20         | 4
    }

    def "all work run to completion for multiple queues when using multiple threads #maxThreads"() {
        given:
        def amountOfWork = 10
        setupBuildOperationExecutor(maxThreads)
        outerOperationCompletion.leaseFinish() // The work of this test is done by other threads
        def worker = new SimpleWorker()
        def numberOfQueues = 5
        def operations = [