LockingThread thread = new LockingThread(lockA);
    thread.start();

    thread.waitUntilHoldingLock();
    assertFalse(lockA.tryLock());

    thread.releaseLockAndFinish();
    assertTrue(lockA.tryLock());
  }

  public void testReentrantWriteLock_tryLock() throws Exception {
    LockingThread thread = new LockingThread(writeLockA);
    thread.start();

    private static final int MAX_LOOP_COUNT = 10;

    protected Thread runningThread;

    protected AtomicBoolean running = new AtomicBoolean();

    public AccessTimeoutTarget(final Thread thread) {
        runningThread = thread;
        running.set(true);
    }

    /*
     * (non-Javadoc)
     *

    }

    @Override
    public int size() {
      assertTrue(Thread.holdsLock(mutex));
      return super.size();
    }

    @Override
    public boolean isEmpty() {
      assertTrue(Thread.holdsLock(mutex));
      return super.isEmpty();
    }

    @Override
    public @Nullable V remove(Object object) {
      assertTrue(Thread.holdsLock(mutex));
      return super.remove(object);
    }

    @Override

        server.start();

        final String url = "http://localhost:7070/";
        try {
            final ResponseData responseData = httpClient.doHead(url);
            Thread.sleep(100);
            assertNotNull(responseData.getLastModified());
            assertTrue(responseData.getLastModified().getTime() < new Date().getTime());
        } finally {
            server.stop();
        }

            }
        }, 1, true);

        assertNotNull(TimeoutManager.getInstance().thread);
        Thread.sleep(2000);
        assertTrue(expiredCount > 0);
        assertEquals(1, TimeoutManager.getInstance().getTimeoutTaskCount());
        TimeoutManager.getInstance().stop();
        assertNull(TimeoutManager.getInstance().thread);
        Thread.sleep(10);
        int count = expiredCount;
        task.stop();

            });
        } catch (final Exception e) {
            logger.warn("Failed to write a thread dump to {}", file, e);
        }
    }

    public static void processThreadDump(final Consumer<String> writer) {
        for (final Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
            writer.accept("Thread: " + entry.getKey());
            final StackTraceElement[] trace = entry.getValue();

  class Interruptenator extends Thread {
    final AtomicBoolean shutdown;

    Interruptenator(final Thread interruptee) {
      this(interruptee, new AtomicBoolean(false));
    }

    @SuppressWarnings("ThreadPriorityCheck") // TODO: b/175898629 - Consider onSpinWait.
    Interruptenator(final Thread interruptee, final AtomicBoolean shutdown) {
      super(

  }

  private fun sleep(delayMillis: Int) {
    try {
      Thread.sleep(delayMillis.toLong())
    } catch (e: InterruptedException) {
      Thread.currentThread().interrupt()
    }
  }

  private fun interruptLater(delayMillis: Int) {
    val toInterrupt = Thread.currentThread()
    val interruptingCow =
      Thread {
        sleep(delayMillis)
        toInterrupt.interrupt()
      }

    checkNotNull(runnable, "Runnable was null.");
    checkNotNull(executor, "Executor was null.");

    // Lock while we check state. We must maintain the lock while adding the new pair so that
    // another thread can't run the list out from under us. We only add to the list if we have not
    // yet started execution.
    synchronized (this) {
      if (!executed) {

import javax.annotation.CheckForNull;

/**
 * A reference queue with an associated background thread that dequeues references and invokes
 * {@link FinalizableReference#finalizeReferent()} on them.
 *
 * <p>Keep a strong reference to this object until all of the associated referents have been
 * finalized. If this object is garbage collected earlier, the backing thread will not invoke {@code
 * finalizeReferent()} on the remaining references.
 *