private void shutdown() {
writerRunner.shutdown();
readerRunner.shutdown();
if (writerThread.isAlive()) {
writerThread.interrupt();
}
if (readerThread.isAlive()) {
readerThread.interrupt();
}
}
public static void killAWTThreads(ThreadGroup threadGroup) {
Thread[] threadList = new Thread[threadGroup.activeCount()];
threadGroup.enumerate(threadList);
for (int i = 0; i < threadList.length; i++) {
Thread t = threadList[i];
if (t != null) {
String name = t.getName();
if (name.startsWith("AWT")) {
out("Interrupting thread '".concat(t.toString()).concat("'"));
t.interrupt();
}
}
}
if (threadGroup.getParent() != null) {
killAWTThreads(threadGroup.getParent());
}
}
@Test
public void testAPIMPubAndReceipt() throws Exception {
// Create a listener
CountDownLatch listeningSignal = new CountDownLatch(1);
CountDownLatch doneSignal = new CountDownLatch(1);
Thread listener = new ListenerThread(listeningSignal, doneSignal);
listener.start();
listeningSignal.await();
// Publish an APIM event
try {
Map<String, List<String>> mdMap = new HashMap<String, List<String>>();
List<String> destinations = new ArrayList<String>();
destinations.add("fedora.apim.update");
mdMap.put(MessageType.apimUpdate.toString(), destinations);
Messaging msg = new MessagingImpl(getBaseURL(), mdMap, jmsMgr);
Object[] invocationHandlers = {new NotificationInvocationHandler(msg)};
Management mgmt = new MockManagementDelegate();
Management proxy = (Management) ProxyFactory.getProxy(mgmt, invocationHandlers);
proxy.purgeObject(new MockContext(), "demo:test", null);
} catch (Exception e) {
listener.interrupt();
throw e;
}
// await message receipt & evaluation
doneSignal.await();
}
private static <R> void verifyInvocationCannotBeInterrupted(final WSTester<R> inTester)
throws Exception {
resetServiceParameters();
getMockSAService().setSleep(true);
inTester.setReturnValue(false);
final Semaphore sema = new Semaphore(0);
final AtomicReference<Exception> interruptFailure = new AtomicReference<Exception>();
Thread t =
new Thread() {
@Override
public void run() {
sema.release();
try {
inTester.invokeApi(false);
} catch (Exception ex) {
interruptFailure.set(ex);
}
}
};
t.start();
// Wait for the thread to be started
sema.acquire();
// Interrupt it as soon as it is found started
t.interrupt();
// wait for it to end
t.join();
// verify that we are not able to interrupt it
assertNull("API invocation got interrupted!", interruptFailure.get());
}
/** Stops unicast and multicast receiver threads */
void stopThreads() {
Thread tmp;
// 1. Stop the multicast receiver thread
if (mcast_receiver != null) {
if (mcast_receiver.isAlive()) {
tmp = mcast_receiver;
mcast_receiver = null;
closeMulticastSocket(); // will cause the multicast thread to terminate
tmp.interrupt();
try {
tmp.join(100);
} catch (Exception e) {
}
tmp = null;
}
mcast_receiver = null;
}
// 2. Stop the unicast receiver thread
if (ucast_receiver != null) {
ucast_receiver.stop();
ucast_receiver = null;
}
// 3. Stop the in_packet_handler thread
if (incoming_packet_handler != null) {
incoming_packet_handler.stop();
}
}
@Override
protected void onCancelPressed() {
super.onUpdatePressed();
if (installerThread != null) {
installerThread.interrupt();
}
}
public void run() {
if (Thread.currentThread() != this.mt)
throw (new RuntimeException("MainFrame is being run from an invalid context"));
Thread ui = new HackThread(p, "Haven UI thread");
ui.start();
try {
try {
Session sess = null;
while (true) {
UI.Runner fun;
if (sess == null) {
Bootstrap bill = new Bootstrap(Config.defserv, Config.mainport);
if ((Config.authuser != null) && (Config.authck != null)) {
bill.setinitcookie(Config.authuser, Config.authck);
Config.authck = null;
}
fun = bill;
setTitle(String.format("Amish Paradise %s", version));
} else {
fun = new RemoteUI(sess);
setTitle(String.format("Amish Paradise %s \u2013 %s", version, sess.username));
}
sess = fun.run(p.newui(sess));
}
} catch (InterruptedException e) {
}
savewndstate();
} finally {
ui.interrupt();
dispose();
}
}
public void onDestroy() {
running = false;
if (scanThread != null) scanThread.interrupt();
if (myWLocate != null) myWLocate.doPause();
sensorManager.unregisterListener(
this, sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER));
if (scanData.getmView() != null) {
((WindowManager) getSystemService(WINDOW_SERVICE)).removeView(scanData.getmView());
scanData.setmView(null);
}
try {
if (wl != null) wl.release();
} catch (RuntimeException re) {
}
wl = null;
try {
scanThread.join(1000);
} catch (InterruptedException ie) {
}
System.exit(0);
}
/** Stop listening on the server port. */
public void shutdown() {
if (listener != null) {
Thread l = listener;
listener = null;
l.interrupt();
}
}
/** awaitUninterruptibly is uninterruptible */
public void testAwaitUninterruptibly() {
final Mutex sync = new Mutex();
final ConditionObject c = sync.newCondition();
final BooleanLatch pleaseInterrupt = new BooleanLatch();
Thread t =
newStartedThread(
new CheckedRunnable() {
public void realRun() {
sync.acquire();
assertTrue(pleaseInterrupt.releaseShared(0));
c.awaitUninterruptibly();
assertTrue(Thread.interrupted());
assertHasWaitersLocked(sync, c, NO_THREADS);
sync.release();
}
});
pleaseInterrupt.acquireShared(0);
sync.acquire();
assertHasWaitersLocked(sync, c, t);
sync.release();
t.interrupt();
assertHasWaitersUnlocked(sync, c, t);
assertThreadStaysAlive(t);
sync.acquire();
assertHasWaitersLocked(sync, c, t);
assertHasExclusiveQueuedThreads(sync, NO_THREADS);
c.signal();
assertHasWaitersLocked(sync, c, NO_THREADS);
assertHasExclusiveQueuedThreads(sync, t);
sync.release();
awaitTermination(t);
}
public void stopEvaluate() {
// user requested run be stopped so tell
// run thread to stop
Thread tmp = runThread;
runThread = null;
tmp.interrupt();
}
/** getSharedQueuedThreads returns all shared waiting threads */
public void testGetSharedQueuedThreads_Shared() {
final BooleanLatch l = new BooleanLatch();
assertHasSharedQueuedThreads(l, NO_THREADS);
Thread t1 =
newStartedThread(
new CheckedInterruptedRunnable() {
public void realRun() throws InterruptedException {
l.acquireSharedInterruptibly(0);
}
});
waitForQueuedThread(l, t1);
assertHasSharedQueuedThreads(l, t1);
Thread t2 =
newStartedThread(
new CheckedRunnable() {
public void realRun() throws InterruptedException {
l.acquireSharedInterruptibly(0);
}
});
waitForQueuedThread(l, t2);
assertHasSharedQueuedThreads(l, t1, t2);
t1.interrupt();
awaitTermination(t1);
assertHasSharedQueuedThreads(l, t2);
assertTrue(l.releaseShared(0));
awaitTermination(t2);
assertHasSharedQueuedThreads(l, NO_THREADS);
}
private void timeoutIfStillRunning(Thread t) {
if (t.isAlive()) {
log.warn("Scenario timed out after " + scenarioTimeoutMillis + " millis, will interrupt");
stepProcessor.setInterruptingOnTimeout(true);
t.interrupt(); // first try to interrupt to see if this can unblock/fail the scenario
}
}
/** {@inheritDoc} */
public void updateBlock(Block oldblock, Block newblock) throws IOException {
if (oldblock.getBlockId() != newblock.getBlockId()) {
throw new IOException(
"Cannot update oldblock (=" + oldblock + ") to newblock (=" + newblock + ").");
}
for (; ; ) {
final List<Thread> threads = tryUpdateBlock(oldblock, newblock);
if (threads == null) {
return;
}
// interrupt and wait for all ongoing create threads
for (Thread t : threads) {
t.interrupt();
}
for (Thread t : threads) {
try {
t.join();
} catch (InterruptedException e) {
DataNode.LOG.warn("interruptOngoingCreates: t=" + t, e);
}
}
}
}
public synchronized void stop() {
running = false;
try {
thread.join();
} catch (InterruptedException e) {
thread.interrupt();
}
}
public synchronized void countDownInterrupt() {
// In MetaSearchImpl.topTask_search() we schedule multiple MetaSearchResult.topTask_run()
// tasks which then call countDownInterrupt
// because we synchronize we don't check here even though that's a little more dangerous that I
// would like it to be...
// perm.checkWrite(this);
if (thread_ != null && --counter_ == 0) thread_.interrupt();
}
/** Request that the loading of the applet be stopped. */
protected synchronized void stopLoading() {
// REMIND: fill in the body
if (loaderThread != null) {
// System.out.println("Interrupting applet loader thread: " + loaderThread);
loaderThread.interrupt();
} else {
setLoadAbortRequest();
}
}
void setMessage(Animator a) {
anim = a;
who.setText(a.author());
ref.setText(a.description());
pan.remove(last);
last = a.container();
pan.add(last, "Center");
if (T != null) T.interrupt();
}
@Override
public void interrupt() {
try {
jmsMgr.close();
} catch (MessagingException e) {
fail(e.getMessage());
} finally {
super.interrupt();
}
}
@Override
public void testEnded(String host) {
workerThread.interrupt();
shutdownConnectors();
// reset autoFileName for next test run
autoFileBaseName = null;
counter = 0;
super.testEnded(host);
}
protected void handleInterruptRequest(Address source, long requestId) {
Owner owner = new Owner(source, requestId);
Runnable runnable = removeKeyForValue(_running, owner);
Thread thread = null;
if (runnable != null) {
thread = _runnableThreads.remove(runnable);
}
if (thread != null) {
thread.interrupt();
} else if (log.isTraceEnabled())
log.trace("Message could not be interrupted due to it already returned");
}
public void stop() {
Thread tmp;
if (thread != null && thread.isAlive()) {
running = false;
tmp = thread;
thread = null;
closeSocket(); // this will cause the thread to break out of its loop
tmp.interrupt();
tmp = null;
}
thread = null;
}
@Test
public void testMapRecordIdleEvictionOnMigration() throws InterruptedException {
Config cfg = new Config();
final String name = "testMapRecordIdleEvictionOnMigration";
MapConfig mc = cfg.getMapConfig(name);
int maxIdleSeconds = 10;
int size = 100;
final int nsize = size / 5;
mc.setMaxIdleSeconds(maxIdleSeconds);
TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(3);
HazelcastInstance instance1 = factory.newHazelcastInstance(cfg);
final IMap map = instance1.getMap(name);
final CountDownLatch latch = new CountDownLatch(size - nsize);
map.addEntryListener(
new EntryAdapter() {
public void entryEvicted(EntryEvent event) {
latch.countDown();
}
},
false);
for (int i = 0; i < size; i++) {
map.put(i, i);
}
final Thread thread =
new Thread(
new Runnable() {
public void run() {
while (!Thread.currentThread().isInterrupted()) {
try {
for (int i = 0; i < nsize; i++) {
map.get(i);
}
Thread.sleep(1000);
} catch (HazelcastInstanceNotActiveException e) {
return;
} catch (InterruptedException e) {
return;
}
}
}
});
thread.start();
HazelcastInstance instance2 = factory.newHazelcastInstance(cfg);
HazelcastInstance instance3 = factory.newHazelcastInstance(cfg);
assertTrue(latch.await(1, TimeUnit.MINUTES));
Assert.assertEquals(nsize, map.size());
thread.interrupt();
thread.join(5000);
}
/** Disconnects from running debugged process. */
public void disconnect() throws DebuggerException {
threadGroup.setRemoteThreadGroup(null);
if (remoteDebugger != null) {
remoteDebugger.close();
remoteDebugger = null;
}
if (debuggerThread != null) {
debuggerThread.interrupt();
debuggerThread.stop();
}
super.finishDebugger();
synchronizer = null;
}
@Override
public synchronized void close() {
logger.info("closing Remote River on this node");
closed = true;
if (coordinatorThread != null) {
coordinatorThread.interrupt();
}
// free instances created in #start()
coordinatorThread = null;
coordinatorInstance = null;
synchronized (riverInstances) {
riverInstances.remove(riverName().getName());
}
}
@Override
public void stop() {
isStopped = true;
if (schedulingThread != null) {
synchronized (schedulingThread) {
schedulingThread.interrupt();
}
}
candidateWorkers.clear();
scheduledRequests.clear();
LOG.info("Task Scheduler stopped");
super.stop();
}
/** tryAcquireNanos is interruptible */
public void testTryAcquireNanos_Interruptible() {
final Mutex sync = new Mutex();
sync.acquire();
Thread t =
newStartedThread(
new CheckedInterruptedRunnable() {
public void realRun() throws InterruptedException {
sync.tryAcquireNanos(MILLISECONDS.toNanos(2 * LONG_DELAY_MS));
}
});
waitForQueuedThread(sync, t);
t.interrupt();
awaitTermination(t);
}
/** @see java.lang.Runnable#run() */
public void run() {
final Thread thread = Thread.currentThread();
while (!Thread.interrupted()) {
m_set.add(m_touchable);
m_list.add(m_touchable);
try {
synchronized (thread) {
thread.wait();
}
} catch (InterruptedException e) {
// propagate interrupt
thread.interrupt();
}
}
}
/** Disconnects from running debugged process. */
public void disconnect() throws DebuggerException {
if (breakpointMain != null) {
for (int x = 0; x < breakpointMain.length; x++) breakpointMain[x].remove();
breakpointMain = null;
}
try {
if (virtualMachine != null) virtualMachine.dispose();
} catch (VMDisconnectedException e) {
}
if (threadManager != null) threadManager.finish();
if (debuggerThread != null) {
debuggerThread.interrupt();
debuggerThread.stop();
}
super.finishDebugger();
}
public void shutdown(boolean join) {
shutdown = true;
if (q2Thread != null) {
log.info("shutting down");
q2Thread.interrupt();
if (join) {
try {
q2Thread.join();
log.info("shutdown done");
} catch (InterruptedException e) {
log.warn(e);
}
}
}
q2Thread = null;
}
