}

    void stopInterrupting() {
      shouldStop = true;
    }
  }

  /** Interrupts the current thread after sleeping for the specified delay. */
  static void requestInterruptIn(final long time, final TimeUnit unit) {
    checkNotNull(unit);
    final Thread interruptee = Thread.currentThread();
    new Thread(
            new Runnable() {
              @Override
              public void run() {
                try {

    @Override
    public boolean offer(E o) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.offer(o);
    }

    @Override
    public @Nullable E poll() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.poll();
    }

    @Override
    public E remove() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.remove();
    }

    @Override

    }

    private class ThreadHandleImpl implements ThreadHandle {
        private final Thread thread;
        private final Set<Thread.State> blockedStates = EnumSet.of(Thread.State.BLOCKED, Thread.State.TIMED_WAITING,
                Thread.State.WAITING);

        public ThreadHandleImpl(Thread thread) {
            this.thread = thread;
        }

        @Override
        public ThreadHandle waitFor() {

    private static final Map<Runnable, Thread> HOOKS = new ConcurrentHashMap<Runnable, Thread>();

    public static void addShutdownHook(Runnable shutdownHook) {
        Thread thread = new Thread(shutdownHook, "gradle-shutdown-hook");
        HOOKS.put(shutdownHook, thread);
        Runtime.getRuntime().addShutdownHook(thread);
    }

    public static void removeShutdownHook(Runnable shutdownHook) {

        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(

	// propagated into a newly created thread (via clone), or that thread
	// is actually being re-used, then we should get scheduled on such a
	// thread with high likelihood.
	done := make(chan bool)
	go func() {
		runtime.LockOSThread()

		// Get the CWD and check if this is the same as the main thread's
		// CWD. Every thread should share the same CWD.

            start {
                thread.blockUntil.running
                lifecycle.stop()
            }
            start {
                lifecycle.use {
                    instant.running
                    thread.blockUntil.failure
                }
            }
            operation.failure {
                thread.blockUntil.running
                thread.block()
                lifecycle.use {}

                        thread.blockUntil.worker2
                    }
                    instant.acquired
                }
            }
            start {
                thread.blockUntil.worker1
                registry.runAsWorkerThread {
                    instant.worker2
                    thread.block()
                    instant.worker2Finished
                }

  public final void run() {
    /*
     * Set runner thread before checking isDone(). If we were to check isDone() first, the task
     * might be cancelled before we set the runner thread. That would make it impossible to
     * interrupt, yet it will still run, since interruptTask will leave the runner value null,
     * allowing the CAS below to succeed.
     */
    Thread currentThread = Thread.currentThread();

    }

    def "can use arbitrary thread to define an instant"() {
        given:
        def action = { instant.actionExecuted }
        def thread = new Thread(action)

        when:
        thread.start()
        thread.join()

        then:
        instant.actionExecuted
    }

    def "fails when waiting for an instant that is not defined by any thread"() {
        instant.timeout = 100