public void stop() {
try {
flush();
} catch (IOException e) {
LOGGER.error("Error flushing", e);
}
try {
close();
} catch (IOException e) {
LOGGER.error("Error closing", e);
}
try {
backgroundFlushTask.shutdown();
// Wait a while for existing tasks to terminate
if (!backgroundFlushTask.awaitTermination(15, TimeUnit.SECONDS)) {
backgroundFlushTask.shutdownNow(); // Cancel currently executing tasks
// Wait a while for tasks to respond to being cancelled
if (!backgroundFlushTask.awaitTermination(15, TimeUnit.SECONDS)) {
LOGGER.error("Stream did not terminate");
}
}
} catch (InterruptedException ie) {
// (Re-)Cancel if current thread also interrupted
backgroundFlushTask.shutdownNow();
// Preserve interrupt status
Thread.currentThread().interrupt();
}
}
/**
* Test to make sure we reschedule the task for execution if the new requested execution is
* earlier than the previous one
*/
public void testRescheduleForEarlierTime() throws InterruptedException {
ScheduledExecutorService ex = Executors.newScheduledThreadPool(1);
MyConflationListener listener = new MyConflationListener();
OneTaskOnlyExecutor decorator = new OneTaskOnlyExecutor(ex, listener);
final CountDownLatch latch = new CountDownLatch(1);
final AtomicInteger counter = new AtomicInteger();
Runnable increment =
new Runnable() {
public void run() {
counter.incrementAndGet();
}
};
decorator.schedule(increment, 120, TimeUnit.SECONDS);
decorator.schedule(increment, 10, TimeUnit.MILLISECONDS);
long start = System.nanoTime();
ex.shutdown();
ex.awaitTermination(60, TimeUnit.SECONDS);
long elapsed = System.nanoTime() - start;
assertEquals(1, counter.get());
assertEquals(1, listener.getDropCount());
assertTrue(elapsed < TimeUnit.SECONDS.toNanos(120));
}
/** Stop the decommission monitor thread, waiting briefly for it to terminate. */
void close() {
executor.shutdownNow();
try {
executor.awaitTermination(3000, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
}
}
public void close() throws IOException {
flush();
if (!commitExecutor.isShutdown()) {
commitExecutor.shutdown();
try {
if (!commitExecutor.awaitTermination(5, TimeUnit.MINUTES))
throw new OException("Background data flush task can not be stopped.");
} catch (InterruptedException e) {
OLogManager.instance().error(this, "Data flush thread was interrupted");
Thread.interrupted();
throw new OException("Data flush thread was interrupted", e);
}
}
synchronized (syncObject) {
for (OFileClassic fileClassic : files.values()) {
if (fileClassic.isOpen()) fileClassic.close();
}
if (nameIdMapHolder != null) {
nameIdMapHolder.setLength(0);
for (Map.Entry<String, Long> entry : nameIdMap.entrySet()) {
writeNameIdEntry(new NameFileIdEntry(entry.getKey(), entry.getValue()), false);
}
nameIdMapHolder.getFD().sync();
nameIdMapHolder.close();
}
}
}
public void delete() throws IOException {
synchronized (syncObject) {
for (long fileId : files.keySet()) doDeleteFile(fileId);
if (nameIdMapHolderFile != null) {
nameIdMapHolder.close();
if (!nameIdMapHolderFile.delete())
throw new OStorageException(
"Can not delete disk cache file which contains name-id mapping.");
}
}
if (!commitExecutor.isShutdown()) {
commitExecutor.shutdown();
try {
if (!commitExecutor.awaitTermination(5, TimeUnit.MINUTES))
throw new OException("Background data flush task can not be stopped.");
} catch (InterruptedException e) {
OLogManager.instance().error(this, "Data flush thread was interrupted");
Thread.interrupted();
throw new OException("Data flush thread was interrupted", e);
}
}
}
private void stop() {
log.info("ExecutorManager stopping...");
scheduler.shutdown();
try {
scheduler.awaitTermination(SHUTDOWN_TIMEOUT, TimeUnit.MILLISECONDS);
} catch (Exception e) {
log.error("scheduler await termination error", e);
}
canceller.shutdown();
try {
canceller.awaitTermination(0, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
log.error("canceller await termination error", e);
}
nearRealTimeOrderedTasksMap.clear();
}
public void testBlockingTake() throws InterruptedException {
final CoalescedPipe<String> coalescedPipe = new CoalescedPipe<String>();
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
scheduledExecutorService.schedule(
new Runnable() {
public void run() {
try {
coalescedPipe.put("test1");
} catch (InterruptedException ie) {
fail(ie.getMessage());
}
}
},
500,
TimeUnit.MILLISECONDS);
long startTime = System.currentTimeMillis();
assertEquals("test1", coalescedPipe.take());
assertTrue((System.currentTimeMillis() - startTime) > 250L);
scheduledExecutorService.shutdownNow();
scheduledExecutorService.awaitTermination(120, TimeUnit.SECONDS);
}
public static synchronized void clearThreadPools() {
if (globalThreadPool != null) {
globalThreadPool.shutdown();
try {
if (!globalThreadPool.awaitTermination(10, TimeUnit.SECONDS)) {
throw new IllegalStateException("Couldn't finish the globalThreadPool");
}
} catch (InterruptedException e) {
} finally {
globalThreadPool = null;
}
}
if (globalScheduledThreadPool != null) {
globalScheduledThreadPool.shutdown();
try {
if (!globalScheduledThreadPool.awaitTermination(10, TimeUnit.SECONDS)) {
throw new IllegalStateException("Couldn't finish the globalScheduledThreadPool");
}
} catch (InterruptedException e) {
} finally {
globalScheduledThreadPool = null;
}
}
}
@Test
public void shouldNotExhaustThreads() throws Exception {
final ScheduledExecutorService executorService =
Executors.newScheduledThreadPool(2, testingThreadFactory);
final GremlinExecutor gremlinExecutor =
GremlinExecutor.build()
.executorService(executorService)
.scheduledExecutorService(executorService)
.create();
final AtomicInteger count = new AtomicInteger(0);
assertTrue(
IntStream.range(0, 1000)
.mapToObj(i -> gremlinExecutor.eval("1+1"))
.allMatch(
f -> {
try {
return (Integer) f.get() == 2;
} catch (Exception ex) {
throw new RuntimeException(ex);
} finally {
count.incrementAndGet();
}
}));
assertEquals(1000, count.intValue());
executorService.shutdown();
executorService.awaitTermination(30000, TimeUnit.MILLISECONDS);
}
public void shutdownBlocking() {
service.shutdown();
try {
service.awaitTermination(defaultExpiration * 2, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
throw new AssertionError(e);
}
}
synchronized void shutdown() {
stop();
executor.shutdown();
try {
executor.awaitTermination(3, TimeUnit.SECONDS);
} catch (InterruptedException e) {
executor.shutdownNow();
}
}
void stopTrashExecutor() {
trashExecutor.shutdown();
try {
trashExecutor.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
trashExecutor = null;
} catch (InterruptedException e) {
logger.log(Level.SEVERE, e.getLocalizedMessage(), e);
}
}
public void passivate() throws Exception {
circuitBreaker.removeVetoableChangeListener(this);
if (receiverExecutor != null) {
receiverExecutor.shutdown();
receiverExecutor.awaitTermination(30, TimeUnit.SECONDS);
}
logger.info("Mail service shutdown");
}
@Test
public void testDeadlock() throws Exception {
LuceneTestCase.assumeFalse(
"This test fails on UNIX with Turkish default locale (https://issues.apache.org/jira/browse/LUCENE-6036)",
new Locale("tr").getLanguage().equals(Locale.getDefault().getLanguage()));
// pick random codec names for stress test in separate process:
final Random rnd = RandomizedContext.current().getRandom();
Set<String> avail;
final String codecName =
new ArrayList<>(avail = Codec.availableCodecs()).get(rnd.nextInt(avail.size()));
final String pfName =
new ArrayList<>(avail = PostingsFormat.availablePostingsFormats())
.get(rnd.nextInt(avail.size()));
final String dvfName =
new ArrayList<>(avail = DocValuesFormat.availableDocValuesFormats())
.get(rnd.nextInt(avail.size()));
// spawn separate JVM:
final Process p =
new ProcessBuilder(
Paths.get(System.getProperty("java.home"), "bin", "java").toString(),
"-cp",
System.getProperty("java.class.path"),
getClass().getName(),
codecName,
pfName,
dvfName)
.inheritIO()
.start();
final ScheduledExecutorService scheduler =
Executors.newSingleThreadScheduledExecutor(new NamedThreadFactory("processKiller"));
final ScheduledFuture<?> f =
scheduler.schedule(
new Runnable() {
@Override
public void run() {
p.destroy();
}
},
30,
TimeUnit.SECONDS);
try {
final int exitCode = p.waitFor();
if (f.cancel(false)) {
assertEquals("Process died abnormally", 0, exitCode);
} else {
fail("Process did not exit after 30 secs -> classloader deadlock?");
}
} finally {
scheduler.shutdown();
while (!scheduler.awaitTermination(1, TimeUnit.MINUTES)) ;
}
}
@Test
public void shouldStopSchedulingJobPoller() throws Exception {
// given
when(executorService.awaitTermination(1, TimeUnit.MINUTES)).thenReturn(true);
// when
jobWorkerDaemon.stop();
// then
verify(executorService).shutdown();
}
@Override
public boolean stop() {
_hostScanScheduler.shutdownNow();
try {
_hostScanScheduler.awaitTermination(3000, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
}
shutdownCleanup();
return true;
}
@Override
public synchronized void shutdown() throws Throwable {
modeSwitcherExecutor.shutdown();
modeSwitcherExecutor.awaitTermination(60, TimeUnit.SECONDS);
haCommunicationLife.shutdown();
switchToMaster.close();
switchToMaster = null;
switchToSlave = null;
}
public void stop() {
executor.shutdownNow();
try {
if (executor.awaitTermination(1, TimeUnit.SECONDS)) {
logger.info("metric reporters stopped.");
} else {
logger.info("metric reporters can't stopped in 1 seconds, force stopped");
}
} catch (InterruptedException ignored) {
// do nothing
}
}
@Test
public void shouldForceStoppingSchedulingJobPollerAfterOneMinute() throws Exception {
// given
when(executorService.awaitTermination(1, TimeUnit.MINUTES)).thenReturn(false).thenReturn(true);
// when
jobWorkerDaemon.stop();
// then
verify(executorService).shutdown();
verify(executorService).shutdownNow();
}
public void stop() {
/** Shutdown the scheduler and clear out any remaining tasks */
try {
mScheduler.shutdown();
mScheduler.awaitTermination(100, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
/* Do nothing ... we're shutting down */
// mLog.error( "DFTProcessor - exception while awaiting shutdown of "
// + "calculation scheduler for reset", e );
}
}
@Test
public void shouldNotShutdownExecutorServicesSuppliedToGremlinExecutor() throws Exception {
final ScheduledExecutorService service =
Executors.newScheduledThreadPool(4, testingThreadFactory);
final GremlinExecutor gremlinExecutor =
GremlinExecutor.build().executorService(service).scheduledExecutorService(service).create();
gremlinExecutor.close();
assertFalse(service.isShutdown());
service.shutdown();
service.awaitTermination(30000, TimeUnit.MILLISECONDS);
}
@Override
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
boolean result = true;
long now = System.nanoTime();
long timeRemaining = unit.toNanos(timeout);
for (ScheduledExecutorService w : workers) {
result = result && w.awaitTermination(timeRemaining, TimeUnit.NANOSECONDS);
long elapsed = System.nanoTime() - now;
timeRemaining = Math.min(1, timeout - elapsed);
}
return result;
}
private void shutdownExecutor() {
if (executor != null) {
executor.shutdown();
try {
if (!executor.awaitTermination(1, TimeUnit.SECONDS)) {
executor.shutdownNow();
}
} catch (InterruptedException e) {
executor.shutdownNow();
}
}
}
private synchronized void stopScheduledExecutor() {
if (scheduledExecutorService == null) {
return;
}
try {
scheduledExecutorService.shutdown();
scheduledExecutorService.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
running.set(false);
scheduledExecutorService = null;
} catch (InterruptedException e) {
log.timedOutWaitingShutdown(indexName);
}
}
/** Close this {@link Publisher}. This will also close the underlying {@link Pubsub} client. */
@Override
public void close() {
// TODO (dano): fail outstanding futures
scheduler.shutdownNow();
try {
scheduler.awaitTermination(30, SECONDS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
pubsub.close();
closeFuture.complete(null);
listener.publisherClosed(Publisher.this);
}
/** Called by APAM when an instance of this implementation is removed */
public void deleteInst() {
logger.info("A user instance desapeared");
instanciationService.shutdown();
try {
instanciationService.awaitTermination(5, TimeUnit.SECONDS);
logger.debug("instanciation acocunt service terminate.");
} catch (InterruptedException e) {
// instanciationService has probably terminated, but some problem
// happened.
logger.debug("Account instanciation service thread crash at termination");
}
}
@Test
public void shouldForceStoppingSchedulingJobPollerWhenInterruptedExceptionIsThrow()
throws Exception {
// given
when(executorService.awaitTermination(1, TimeUnit.MINUTES))
.thenThrow(new InterruptedException());
// when
jobWorkerDaemon.stop();
// then
verify(executorService).shutdown();
verify(executorService).shutdownNow();
}
@Override
public synchronized void stop() {
executor.shutdown();
try {
executor.awaitTermination(10L, TimeUnit.SECONDS);
} catch (InterruptedException ex) {
logger.info("Interrupted while awaiting termination", ex);
}
executor.shutdownNow();
super.stop();
sourceCounter.stop();
logger.info("SpoolDir source {} stopped. Metrics: {}", getName(), sourceCounter);
}
public void close() {
closed = true;
executor.shutdown();
try {
executor.awaitTermination(2, TimeUnit.SECONDS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
if (activityStorage != null) {
activityStorage.close();
}
for (ActivityValues activityIntValues : valuesMap.values()) {
activityIntValues.close();
}
}
@Test
public void testStartStop() throws Exception {
BufferHandler handler =
new BufferHandler() {
public void bufferReceived(final Object connectionID, final HornetQBuffer buffer) {}
};
Map<String, Object> params = new HashMap<String, Object>();
ConnectionLifeCycleListener listener =
new ConnectionLifeCycleListener() {
public void connectionException(final Object connectionID, final HornetQException me) {}
public void connectionDestroyed(final Object connectionID) {}
public void connectionCreated(
final HornetQComponent component,
final Connection connection,
final String protocol) {}
public void connectionReadyForWrites(Object connectionID, boolean ready) {}
};
pool1 = Executors.newCachedThreadPool();
pool2 =
Executors.newScheduledThreadPool(
HornetQDefaultConfiguration.getDefaultScheduledThreadPoolMaxSize());
NettyAcceptor acceptor = new NettyAcceptor(params, handler, listener, pool1, pool2, null);
addHornetQComponent(acceptor);
acceptor.start();
Assert.assertTrue(acceptor.isStarted());
acceptor.stop();
Assert.assertFalse(acceptor.isStarted());
UnitTestCase.checkFreePort(TransportConstants.DEFAULT_PORT);
acceptor.start();
Assert.assertTrue(acceptor.isStarted());
acceptor.stop();
Assert.assertFalse(acceptor.isStarted());
UnitTestCase.checkFreePort(TransportConstants.DEFAULT_PORT);
pool1.shutdown();
pool2.shutdown();
pool1.awaitTermination(1, TimeUnit.SECONDS);
pool2.awaitTermination(1, TimeUnit.SECONDS);
}
