public static void startSystem() throws ExecutionException, InterruptedException {
// Create the entry gates and link them to the parking lot
for (int i = 0; i < numOfEntries; i++) {
entries.add(new Entry("entry" + i, parkingLot));
}
parkingLot.setEntries(entries);
// Create the exit gates and link them to the parking lot
for (int k = 0; k < numOfExits; k++) {
exits.add(new Exit("exit" + k, parkingLot));
}
parkingLot.setExits(exits);
// Create a thread pool based on the number of entries and exits for this lot
ScheduledExecutorService scheduledExecutorService1 =
Executors.newScheduledThreadPool(numOfEntries);
ScheduledExecutorService scheduledExecutorService2 =
Executors.newScheduledThreadPool(numOfExits);
// Schedule the threads, which will act as Car objects entering and exiting the parking lot
ScheduledFuture<?> scheduledFuture1 =
scheduledExecutorService1.scheduleWithFixedDelay(
new Car(entries, exits, 0), firstCarEntryTime, enteringCarsDelay, TimeUnit.SECONDS);
ScheduledFuture<?> scheduledFuture2 =
scheduledExecutorService2.scheduleWithFixedDelay(
new Car(entries, exits, 1), firstCarExitTime, exitingCarsDelay, TimeUnit.SECONDS);
scheduledFuture1.get();
scheduledFuture2.get();
scheduledExecutorService1.shutdown();
scheduledExecutorService2.shutdown();
}
public void cleanup() {
logger.info("canceling the jobs");
jobHandle.cancel(true);
ciEventsJobHandle.cancel(true);
logger.info("shuting down the scheduler");
ciEventScheduler.shutdown();
controllerEventScheduler.shutdown();
}
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();
}
}
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();
}
@Override
public void stop() {
logger.info("Avro source {} stopping: {}", getName(), this);
server.close();
try {
server.join();
} catch (InterruptedException e) {
logger.info(
"Avro source "
+ getName()
+ ": Interrupted while waiting "
+ "for Avro server to stop. Exiting. Exception follows.",
e);
}
sourceCounter.stop();
connectionCountUpdater.shutdown();
while (!connectionCountUpdater.isTerminated()) {
try {
Thread.sleep(100);
} catch (InterruptedException ex) {
logger.error(
"Interrupted while waiting for connection count executor " + "to terminate", ex);
Throwables.propagate(ex);
}
}
super.stop();
logger.info("Avro source {} stopped. Metrics: {}", getName(), sourceCounter);
}
@Override
public synchronized void close() {
while (!getText().isEmpty()) {
sendMessage();
try {
Thread.sleep(1_000);
} catch (InterruptedException exception) {
executor.shutdown();
LOG.error(getClass() + " A problem occurred while closing sender", exception);
}
}
executor.shutdown();
}
/** stop the scheduler for data collecting jobs. */
public void stop() {
if (isRunning()) {
scheduler.shutdown();
isRunning = false;
LOG.info("Collector shutdown");
}
}
@PreDestroy
public void shutdown() {
request.stop();
readBytes.stop();
writtenBytes.stop();
executor.shutdown();
}
/**
* 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));
}
/**
* Empty this pool, freeing any resources.
*
* @throws IllegalStateException if this pool has not been initialized
*/
@Override
public void close() {
logger.debug("closing connection pool of size {}", available.size() + active.size());
isInitialized();
poolLock.lock();
try {
while (!available.isEmpty()) {
final PooledConnectionProxy pc = available.remove();
pc.getConnection().close();
logger.trace("destroyed connection: {}", pc);
}
while (!active.isEmpty()) {
final PooledConnectionProxy pc = active.remove();
pc.getConnection().close();
logger.trace("destroyed connection: {}", pc);
}
logger.debug("pool closed");
} finally {
poolLock.unlock();
}
logger.debug("shutting down executor");
poolExecutor.shutdown();
logger.debug("executor shutdown");
initialized = false;
}
@Override
public void stop() {
cleanup();
if (!isShared) {
reaper.shutdown();
}
}
/**
* Release the tryClaim of the coordinate. It means that nobody owns the coordinate anymore.
* Requires that that this instance owns the tryClaim to the coordinate.
*/
public void releaseClaim() throws CloudnameException {
scheduler.shutdown();
zkClient.deregisterListener(this);
while (true) {
final TrackedConfig config;
synchronized (trackedConfigList) {
if (trackedConfigList.isEmpty()) {
break;
}
config = trackedConfigList.remove(0);
}
config.stop();
}
sendEventToCoordinateListener(
CoordinateListener.Event.NOT_OWNER, "Released claim of coordinate");
synchronized (lastStatusVersionMonitor) {
try {
zkClient.getZookeeper().delete(path, lastStatusVersion);
} catch (InterruptedException e) {
throw new CloudnameException(e);
} catch (KeeperException e) {
throw new CloudnameException(e);
}
}
}
@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 setPingEnabled(boolean enabled) {
this.pingEnabled = enabled;
if (enabled) {
if (pingScheduler == null) {
long interval = idleTimeoutMs - 5000L;
if (interval < 0) {
interval /= 2;
}
pingScheduler = Executors.newScheduledThreadPool(1);
pingScheduler.scheduleAtFixedRate(
new Runnable() {
@Override
public void run() {
try {
WoopraPing ping =
new WoopraPing(domain, getVisitor().getCookie(), clientInfo, idleTimeoutMs);
ping.ping();
} catch (Throwable t) {
Log.e(TAG, "unknown ping error", t);
}
}
},
interval,
interval,
TimeUnit.MILLISECONDS);
}
} else {
if (pingScheduler != null) {
pingScheduler.shutdown();
pingScheduler = null;
}
}
}
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();
}
}
}
@Test
public void testKeyValueStateInWindowFunctionTumbling() {
final ScheduledExecutorService timerService = Executors.newSingleThreadScheduledExecutor();
try {
final long thirtySeconds = 30_000;
final CollectingOutput<Tuple2<Integer, Integer>> out = new CollectingOutput<>();
final Object lock = new Object();
final StreamTask<?, ?> mockTask = createMockTaskWithTimer(timerService, lock);
StatefulFunction.globalCounts.clear();
AggregatingProcessingTimeWindowOperator<Integer, Tuple2<Integer, Integer>> op =
new AggregatingProcessingTimeWindowOperator<>(
new StatefulFunction(),
fieldOneSelector,
IntSerializer.INSTANCE,
tupleSerializer,
thirtySeconds,
thirtySeconds);
op.setup(mockTask, createTaskConfig(fieldOneSelector, IntSerializer.INSTANCE), out);
op.open();
// because the window interval is so large, everything should be in one window
// and aggregate into one value per key
synchronized (lock) {
for (int i = 0; i < 10; i++) {
StreamRecord<Tuple2<Integer, Integer>> next1 = new StreamRecord<>(new Tuple2<>(1, i));
op.setKeyContextElement(next1);
op.processElement(next1);
StreamRecord<Tuple2<Integer, Integer>> next2 = new StreamRecord<>(new Tuple2<>(2, i));
op.setKeyContextElement(next2);
op.processElement(next2);
}
}
out.waitForNElements(2, 60_000);
List<Tuple2<Integer, Integer>> result = out.getElements();
assertEquals(2, result.size());
Collections.sort(result, tupleComparator);
assertEquals(45, result.get(0).f1.intValue());
assertEquals(45, result.get(1).f1.intValue());
assertEquals(10, StatefulFunction.globalCounts.get(1).intValue());
assertEquals(10, StatefulFunction.globalCounts.get(2).intValue());
op.close();
op.dispose();
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
} finally {
timerService.shutdown();
}
}
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;
}
}
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
// *1
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
// *2
Runnable task1 =
new Runnable() {
public void run() {
System.out.println("Taskrepeating.");
}
};
// *3 每隔5秒执行一次
final ScheduledFuture future1 = service.scheduleAtFixedRate(task1, 0, 1, TimeUnit.SECONDS);
// *4
ScheduledFuture future2 =
service.schedule(
new Callable() {
public String call() {
future1.cancel(true);
return "taskcancelled!";
}
},
10,
TimeUnit.SECONDS);
System.out.println(future2.get());
// *5
service.shutdown();
}
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);
}
}
}
@Override
public void stopLogging() {
super.stopLogging();
if (_rolledPolicyExecutor != null) {
_rolledPolicyExecutor.shutdown();
}
}
@Override
public void shutdown() throws IOException {
isShutDown = true;
httpClient.close();
scalarMeasurementPool.shutdown();
offloadingThreadPool.shutdown();
}
@Test
public void testKeyValueStateInWindowFunction() {
final ScheduledExecutorService timerService = Executors.newSingleThreadScheduledExecutor();
try {
final CollectingOutput<Integer> out = new CollectingOutput<>(50);
final Object lock = new Object();
final StreamTask<?, ?> mockTask = createMockTaskWithTimer(timerService, lock);
StatefulFunction.globalCounts.clear();
// tumbling window that triggers every 20 milliseconds
AccumulatingProcessingTimeWindowOperator<Integer, Integer, Integer> op =
new AccumulatingProcessingTimeWindowOperator<>(
new StatefulFunction(),
identitySelector,
IntSerializer.INSTANCE,
IntSerializer.INSTANCE,
50,
50);
op.setup(mockTask, createTaskConfig(identitySelector, IntSerializer.INSTANCE), out);
op.open();
synchronized (lock) {
op.processElement(new StreamRecord<Integer>(1));
op.processElement(new StreamRecord<Integer>(2));
}
out.waitForNElements(2, 60000);
synchronized (lock) {
op.processElement(new StreamRecord<Integer>(1));
op.processElement(new StreamRecord<Integer>(2));
op.processElement(new StreamRecord<Integer>(1));
op.processElement(new StreamRecord<Integer>(1));
op.processElement(new StreamRecord<Integer>(2));
op.processElement(new StreamRecord<Integer>(2));
}
out.waitForNElements(8, 60000);
List<Integer> result = out.getElements();
assertEquals(8, result.size());
Collections.sort(result);
assertEquals(Arrays.asList(1, 1, 1, 1, 2, 2, 2, 2), result);
assertEquals(4, StatefulFunction.globalCounts.get(1).intValue());
assertEquals(4, StatefulFunction.globalCounts.get(2).intValue());
synchronized (lock) {
op.close();
}
op.dispose();
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
} finally {
timerService.shutdown();
}
}
@Override
public void destroy() {
registers.clear();
configInstances.clear();
configFiles.clear();
scheduleService.shutdown();
init = Boolean.FALSE;
}
public void onDestroy() {
executorService.shutdown();
serializeDownloadQueue();
downloadService.clear(false);
downloadService.unregisterReceiver(ejectEventReceiver);
downloadService.unregisterReceiver(headsetEventReceiver);
downloadService.unregisterReceiver(intentReceiver);
}
public void shutdownBlocking() {
service.shutdown();
try {
service.awaitTermination(defaultExpiration * 2, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
throw new AssertionError(e);
}
}
@Override
public void close() {
try {
scheduler.shutdown();
} catch (Exception e) {
LOG.warn("Error when closing zookeeper based ledger manager: ", e);
}
}
@Override
public void run() {
if (System.currentTimeMillis() > expiryTime) {
scheduledExecutorService.shutdown();
throw new RuntimeException(
"failed to discover beans: " + managedTypes.getServiceEndpoints());
}
if (registered.isEmpty()) {
scheduledExecutorService.shutdown();
log.info("all services registered successfully");
return;
}
for (final AnnotatedType<?> type : managedTypes.getServiceEndpoints()) {
if (!registered.contains(type) || beanManager.getBeans(type.getJavaClass()).size() == 0) {
continue;
}
final MessageCallback callback =
(MessageCallback) CDIServerUtil.lookupBean(beanManager, type.getJavaClass());
registered.remove(type);
// Discriminate on @Command
final Map<String, Method> commandPoints = new HashMap<String, Method>();
for (final AnnotatedMethod method : type.getMethods()) {
if (method.isAnnotationPresent(Command.class)) {
final Command command = method.getAnnotation(Command.class);
for (String cmdName : command.value()) {
if (cmdName.equals("")) cmdName = method.getJavaMember().getName();
commandPoints.put(cmdName, method.getJavaMember());
}
}
}
final String subjectName = CDIServerUtil.resolveServiceName(type.getJavaClass());
if (commandPoints.isEmpty()) {
bus.subscribe(subjectName, callback);
} else {
bus.subscribeLocal(
subjectName, new CommandBindingsCallback(commandPoints, callback, bus));
}
}
}
/** {@inheritDoc} */
@Override
public void stop() {
try {
indexLastDirtyElements(5);
} finally {
executorService.shutdown();
}
}
private void tearDown() throws IOException {
// close job runtime writer
if (jobRuntimeLogBW != null) {
jobRuntimeLogBW.close();
}
// shut pool
if (pool != null) pool.shutdown();
}
/**
* Stop the bundle. Nothing to stop for now.
*
* @param bundleContext <tt>BundleContext</tt> provided by OSGi framework
* @throws Exception if something goes wrong during stop
*/
public void stop(BundleContext bundleContext) throws Exception {
if (logger.isDebugEnabled()) logger.debug("Update checker [STOPPED]");
if (mUpdateExecutor != null) {
mUpdateExecutor.shutdown();
mUpdateExecutor = null;
}
}
