@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); }