} else {
                t.url = args[ai];
            }
        }

        Thread[] threads = new Thread[t.numThreads];
        int ti;

        for (ti = 0; ti < t.numThreads; ti++) {
            threads[ti] = new Thread(t);
            System.out.print(threads[ti].getName());
            threads[ti].start();
        }

        while (t.numComplete < t.numThreads) {
            long delay;

    // Thread#setPriority() already checks for validity. These error messages
    // are nicer though and will fail-fast.
    checkArgument(
        priority >= Thread.MIN_PRIORITY,
        "Thread priority (%s) must be >= %s",
        priority,
        Thread.MIN_PRIORITY);
    checkArgument(
        priority <= Thread.MAX_PRIORITY,
        "Thread priority (%s) must be <= %s",
        priority,
        Thread.MAX_PRIORITY);

              }
              countingRunnable.integer.addAndGet(localRunnable.integer.get());
            }
          };
      threads.add(thread);
    }
  }

  @AfterExperiment
  void after() {
    for (Thread thread : threads) {
      thread.interrupt(); // try to get them to exit
    }
    threads.clear();
  }

  @Footprint
  Object measureSize() {
    return executor;
  }

  @Benchmark

              }
              countingRunnable.integer.addAndGet(localRunnable.integer.get());
            }
          };
      threads.add(thread);
    }
  }

  @AfterExperiment
  void after() {
    for (Thread thread : threads) {
      thread.interrupt(); // try to get them to exit
    }
    threads.clear();
  }

  @Footprint
  Object measureSize() {
    return executor;
  }

  @Benchmark

    executorService =
        new ThreadPoolExecutor(
            NUM_THREADS,
            NUM_THREADS,
            Long.MAX_VALUE,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<Runnable>(1000));
    executorService.prestartAllCoreThreads();
    final AtomicInteger integer = new AtomicInteger();
    // Execute a bunch of tasks to ensure that our threads are allocated and hot
    for (int i = 0; i < NUM_THREADS * 10; i++) {

#### Do-stuff-later pool

Sometimes there's an action required like calling the application layer or responding to a ping, and the thread discovering the action is not the thread that should do the work. We enqueue a runnable on this executor and it gets handled by one of the executor's threads.

### Locks

          public @Nullable Void call() throws Exception {
            assertEquals(Thread.currentThread().getName(), newName.get());
            return null;
          }
        };
    Callables.threadRenaming(callable, newName).call();
    assertEquals(oldName, Thread.currentThread().getName());
  }

  @J2ktIncompatible
  @GwtIncompatible // threads
  public void testRenaming_exceptionalReturn() throws Exception {

   * running will have the given name.
   *
   * @param callable The callable to wrap
   * @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(

            return jvmGcObj;
        }).toArray(n -> new JvmGcObj[n]);
        final Threads threads = jvmStats.getThreads();
        final JvmThreadsObj jvmThreadsObj = new JvmThreadsObj();
        jvmObj.threads = jvmThreadsObj;
        jvmThreadsObj.count = threads.getCount();
        jvmThreadsObj.peak = threads.getPeakCount();
        final Classes classes = jvmStats.getClasses();

// that pass integers back and forth.  No actual
// concurrency, just threads and synchronization
// and foreign code on multiple pthreads.

package main

import (
	big "."
	"runtime"
)

func fibber(c chan *big.Int, out chan string, n int64) {
	// Keep the fibbers in dedicated operating system
	// threads, so that this program tests coordination
	// between pthreads and not just goroutines.
	runtime.LockOSThread()