How to use

getState

method

in

java.lang.Thread

@Override
public State state() {
  return t.getState();
}

@Override
public State state() {
  return t.getState();
}

boolean isWaiting(Thread thread) {
 switch (thread.getState()) {
  case BLOCKED:
  case WAITING:
  case TIMED_WAITING:
   return true;
  default:
   return false;
 }
}

/**
 * @param thread a thread
 * @return a human-readable representation of the thread's stack trace
 */
public static String formatStackTrace(Thread thread) {
 Throwable t = new Throwable(String.format("Stack trace for thread %s (State: %s):",
   thread.getName(), thread.getState()));
 t.setStackTrace(thread.getStackTrace());
 StringWriter sw = new StringWriter();
 t.printStackTrace(new PrintWriter(sw));
 return sw.toString();
}

public Thread.State state()
{
  return thread.getState();
}

static void awaitWaiting(Thread t) {
 while (true) {
  Thread.State state = t.getState();
  switch (state) {
   case RUNNABLE:
   case BLOCKED:
    Thread.yield();
    break;
   case WAITING:
    return;
   default:
    throw new AssertionError("unexpected state: " + state);
  }
 }
}

/** Wait for the given thread to reach the {@link State#TIMED_WAITING} thread state. */
void awaitTimedWaiting(Thread thread) {
 while (true) {
  switch (thread.getState()) {
   case BLOCKED:
   case NEW:
   case RUNNABLE:
   case WAITING:
    Thread.yield();
    break;
   case TIMED_WAITING:
    return;
   case TERMINATED:
   default:
    throw new AssertionError();
  }
 }
}

private static void awaitBlockedOn(Thread t, Object blocker) throws InterruptedException {
 while (!isThreadBlockedOn(t, blocker)) {
  if (t.getState() == Thread.State.TERMINATED) {
   throw new RuntimeException("Thread " + t + " exited unexpectedly");
  }
  Thread.sleep(1);
 }
}

@Override
public boolean test( Thread thread )
{
  State threadState = thread.getState();
  seenStates.add( threadState );
  return possibleStates.contains( threadState );
}

private static boolean isThreadBlockedOn(Thread t, Object blocker) {
 return t.getState() == Thread.State.WAITING && LockSupport.getBlocker(t) == blocker;
}

private synchronized void readSourceAsync() throws ProxyCacheException {
  boolean readingInProgress = sourceReaderThread != null && sourceReaderThread.getState() != Thread.State.TERMINATED;
  if (!stopped && !cache.isCompleted() && !readingInProgress) {
    sourceReaderThread = new Thread(new SourceReaderRunnable(), "Source reader for " + source);
    sourceReaderThread.start();
  }
}

@Override
public String toString()
{
  Thread thread = this.thread;
  return format( "%s[%s,state=%s]", getClass().getSimpleName(), name,
          thread == null ? "dead" : thread.getState() );
}

void joinSuccessfully(long timeoutMillis) {
 Uninterruptibles.joinUninterruptibly(thread, timeoutMillis, MILLISECONDS);
 completed.assertCompletionExpected();
 assertEquals(Thread.State.TERMINATED, thread.getState());
}

void joinSuccessfully() {
 Uninterruptibles.joinUninterruptibly(thread);
 completed.assertCompletionExpected();
 assertEquals(Thread.State.TERMINATED, thread.getState());
}

@Override
public boolean test( Thread thread )
{
  ReflectionUtil.verifyMethodExists( owner, method );
  if ( thread.getState() == Thread.State.WAITING || thread.getState() == Thread.State.TIMED_WAITING )
  {
    for ( StackTraceElement element : thread.getStackTrace() )
    {
      if ( element.getClassName().equals( owner.getName() ) && element.getMethodName().equals( method ) )
      {
        return true;
      }
    }
  }
  return false;
}

/**
 * Waits for the specified time (in milliseconds) for the thread to terminate (using {@link
 * Thread#join(long)}), else interrupts the thread (in the hope that it may terminate later) and
 * fails.
 */
void awaitTermination(Thread t, long timeoutMillis) {
 try {
  t.join(timeoutMillis);
 } catch (InterruptedException ie) {
  threadUnexpectedException(ie);
 } finally {
  if (t.getState() != Thread.State.TERMINATED) {
   t.interrupt();
   fail("Test timed out");
  }
 }
}

/**
 * Spin-waits up to the specified number of milliseconds for the given thread to enter a wait
 * state: BLOCKED, WAITING, or TIMED_WAITING.
 */
void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
 long startTime = System.nanoTime();
 for (; ; ) {
  Thread.State s = thread.getState();
  if (s == Thread.State.BLOCKED || s == Thread.State.WAITING || s == Thread.State.TIMED_WAITING)
   return;
  else if (s == Thread.State.TERMINATED) fail("Unexpected thread termination");
  else if (millisElapsedSince(startTime) > timeoutMillis) {
   threadAssertTrue(thread.isAlive());
   return;
  }
  Thread.yield();
 }
}

 void joinUnsuccessfully(long timeoutMillis) {
  Uninterruptibles.joinUninterruptibly(thread, timeoutMillis, MILLISECONDS);
  completed.assertCompletionNotExpected(timeoutMillis);
  assertFalse(Thread.State.TERMINATED.equals(thread.getState()));
 }
}

@Test
public void testCloseWorkerPool() throws Exception {
 String poolName = "vert.x-" + TestUtils.randomAlphaString(10);
 AtomicReference<Thread> thread = new AtomicReference<>();
 WorkerExecutor worker1 = vertx.createSharedWorkerExecutor(poolName);
 WorkerExecutor worker2 = vertx.createSharedWorkerExecutor(poolName);
 worker1.executeBlocking(fut -> {
  thread.set(Thread.currentThread());
 }, ar -> {
 });
 assertWaitUntil(() -> thread.get() != null);
 worker1.close();
 assertNotSame(thread.get().getState(), Thread.State.TERMINATED);
 worker2.close();
 assertWaitUntil(() -> thread.get().getState() == Thread.State.TERMINATED);
}

public void testThreadFactory() throws InterruptedException {
 final String THREAD_NAME = "ludicrous speed";
 final int THREAD_PRIORITY = 1;
 final boolean THREAD_DAEMON = false;
 ThreadFactory backingThreadFactory =
   new ThreadFactory() {
    @Override
    public Thread newThread(Runnable r) {
     Thread thread = new Thread(r);
     thread.setName(THREAD_NAME);
     thread.setPriority(THREAD_PRIORITY);
     thread.setDaemon(THREAD_DAEMON);
     thread.setUncaughtExceptionHandler(UNCAUGHT_EXCEPTION_HANDLER);
     return thread;
    }
   };
 Thread thread =
   builder.setThreadFactory(backingThreadFactory).build().newThread(monitoredRunnable);
 assertEquals(THREAD_NAME, thread.getName());
 assertEquals(THREAD_PRIORITY, thread.getPriority());
 assertEquals(THREAD_DAEMON, thread.isDaemon());
 assertSame(UNCAUGHT_EXCEPTION_HANDLER, thread.getUncaughtExceptionHandler());
 assertSame(Thread.State.NEW, thread.getState());
 assertFalse(completed);
 thread.start();
 thread.join();
 assertTrue(completed);
}