start {
                workerLeaseService.withLocks([taskLease]) {
                    instant.worker1Locked
                    thread.block()
                    instant.worker1Unlocked
                }
            }
            start {
                thread.blockUntil.worker1Locked
                workerLeaseService.withLocks([taskLease]) {
                    instant.worker2Locked

        logger.log(
            Level.INFO, "Failed to create a thread without inherited thread-local values", t);
      }
    }
    if (thread == null) {
      thread = new Thread((ThreadGroup) null, finalizer, threadName);
    }
    thread.setDaemon(true);

    try {
      if (inheritableThreadLocals != null) {
        inheritableThreadLocals.set(thread, null);
      }
    } catch (Throwable t) {
      logger.log(

                    throw te;
            }

            state = 1;
            te = null;
            thread = new Thread( this, name );
            thread.setDaemon( true );

            synchronized (thread) {
                thread.start();
                thread.wait( timeout );          /* wait for doConnect */

                switch (state) {

  }

  /**
   * Causes this thread to call the named method, and asserts that this thread becomes blocked on
   * the lock-like object. The lock-like object must have a method equivalent to {@link
   * java.util.concurrent.locks.ReentrantLock#hasQueuedThread(Thread)}.
   */
  public void callAndAssertBlocks(String methodName, Object... arguments) throws Exception {

                    }
                }
            }
        }

        lock.lock()
        try {
            threads << thread
            thread.name = "Test thread ${++threadNum}"
        } finally {
            lock.unlock()
        }

        thread.start()
    }

    void stop(Date expiry) {
        lock.lock()
        try {
            if (!threads.isEmpty()) {

    }

    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setName(nextThreadName());
        thread.setContextClassLoader(contextClassloader);
        return thread;
    }

    private String nextThreadName() {
        long count = counter.incrementAndGet();
        return count == 1 ? displayName : displayName + " Thread " + count;
    }

import kotlin.concurrent.thread


/**
 * A thread that comes back to life when [poke]d.
 */
internal
class ResurrectingThread(val name: String, val block: () -> Unit) {

    private
    var thread: Thread? = null

    /**
     * Checks if the thread is alive, resurrecting it if it's not.
     */
    fun poke() = synchronized(this) {
        if (thread?.isAlive != true) {

        (1..10).each { thread ->
            executor.execute {
                def textOut = services.get(StyledTextOutputFactory.class).create('build')
                (1..100).each { iteration ->
                    logger.lifecycle("log message from thread $thread iteration $iteration")
                    print "stdout message "
                    println "from thread $thread iteration $iteration"

     *       observing a null thread does not mean the object is safe to reuse.
     *   <li>If this field's value is some other thread object, we know that it's not our thread.
     *   <li>If this field's value == null because it originally belonged to another thread and that
     *       thread cleared it, we still know that it's not associated with our thread

        }
    }

    @Override
    public <T> T withLock(Factory<T> action) {
        Thread previous = takeOwnership();
        try {
            return action.create();
        } finally {
            releaseOwnership(previous);
        }
    }

    private Thread takeOwnership() {
        final Thread currentThread = Thread.currentThread();
        if (!workerLeaseService.isWorkerThread()) {