/**
     * Flag indicating whether crawler threads run as daemon threads.
     */
    protected boolean daemon = false;

    /**
     * Priority for crawler threads.
     */
    protected int threadPriority = Thread.NORM_PRIORITY;

    /**
     * Reference to the parent thread that started the crawler.
     */
    protected Thread parentThread;

    /**

            });
    assertFalse(task.isDone());
    Thread thread =
        new Thread(
            () -> {
              try {
                task.run();
              } finally {
                exitLatch.countDown();
              }
            },
            "Custom thread name");
    thread.start();
    enterLatch.await();
    assertFalse(task.isDone());

    Stopwatch stopwatch = Stopwatch.createStarted();
    Thread thread = new Thread(new JoinTarget(15));
    thread.start();
    thread.join();
    assertFalse(thread.isAlive());

    joinUninterruptibly(thread);
    joinUninterruptibly(thread, 0, MILLISECONDS);
    joinUninterruptibly(thread, -42, MILLISECONDS);
    joinUninterruptibly(thread, LONG_DELAY_MS, MILLISECONDS);

   * <p>On the other hand, if a signalled thread wakes up to discover that its guard is still not
   * satisfied, it does *not* need to call this method before returning to wait. This can only
   * happen due to spurious wakeup (ignorable) or another thread acquiring the lock before the
   * current thread can and returning the guard to the unsatisfied state. In the latter case the

        }

        // Start all threads
        for (Thread thread : threads) {
            thread.start();
        }

        // Wait for completion
        for (Thread thread : threads) {
            thread.join();
        }

        // Verify no exceptions occurred
        for (int i = 0; i < threadCount; i++) {
            assertNull(exceptions[i], "Thread " + i + " threw exception");

        return instance;
    }

    /**
     * Starts the process.
     */
    public synchronized void start() {
        if (thread == null) {
            thread = new Thread(this, "CoreLib-TimeoutManager");
            thread.setDaemon(true);
            thread.start();
            if (logger.isDebugEnabled()) {
                logger.debug("TimeoutManager started.");
            }
        }
    }

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

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

                switch (state) {
                case 1: /* doConnect never returned */
                    state = 0;
                    thread = null;

    Interruptenator interruptingTask = new Interruptenator(Thread.currentThread());
    Thread interruptingThread = new Thread(interruptingTask);
    interruptingThread.start();
    tearDownAccepter.addTearDown(
        () -> {
          interruptingTask.stopInterrupting();
          interruptingThread.interrupt();
          joinUninterruptibly(interruptingThread, 2500, MILLISECONDS);
          Thread.interrupted();

    Interruptenator interruptingTask = new Interruptenator(Thread.currentThread());
    Thread interruptingThread = new Thread(interruptingTask);
    interruptingThread.start();
    tearDownAccepter.addTearDown(
        () -> {
          interruptingTask.stopInterrupting();
          interruptingThread.interrupt();
          joinUninterruptibly(interruptingThread, 2500, MILLISECONDS);
          Thread.interrupted();

     *       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