@Override
public void dispose() {
if (!hasAlreadyShutdown.getAndSet(true) && executorService != null) {
for (final Future<?> job : jobs) {
if (!job.isCancelled() && !job.isDone()) {
job.cancel(true);
}
}
executorService.shutdown(); // Disable new tasks from being submitted
try {
// Wait a while for existing tasks to terminate
if (!executorService.awaitTermination(AWAIT_TERMINATION_TIMEOUT, TimeUnit.SECONDS)) {
executorService.shutdownNow(); // Cancel currently executing tasks
// Wait a while for tasks to respond to being cancelled
if (!executorService.awaitTermination(AWAIT_TERMINATION_TIMEOUT, TimeUnit.SECONDS)) {
LOG.error("Thread pool did not terminate.");
}
}
} catch (InterruptedException ie) {
// (Re-)Cancel if current thread also interrupted
executorService.shutdownNow();
// Preserve interrupt status
Thread.currentThread().interrupt();
}
executorService.shutdown();
}
}
@Test
public void testDeadLockWithNotify() throws Throwable {
int size = 10;
final ExecutorService es =
new ThreadPoolExecutor(
size * 2, Integer.MAX_VALUE, 30, TimeUnit.SECONDS, new SynchronousQueue());
((ThreadPoolExecutor) es).prestartAllCoreThreads();
for (int i = 0; i < size; i++)
es.execute(new WriteSpaceWithNotifyTask("WriteTask1-" + i, sp1, sp2));
for (int i = 0; i < size; i++)
es.execute(new WriteSpaceWithNotifyTask("WriteTask2-" + i, sp2, sp1));
long stamp = System.currentTimeMillis();
while (((ThreadPoolExecutor) es).getActiveCount() > 0) {
if (System.currentTimeMillis() - stamp < 10000) {
ISOUtil.sleep(100);
continue;
}
es.shutdownNow();
fail("Probably death-lock detected");
return;
}
printAvg(t1, "Avg. write: ");
// es.shutdown();
es.shutdownNow();
es.awaitTermination(5, TimeUnit.SECONDS);
}
void cancelDiscovery1() {
doLog("cancelDiscovery1()...");
if (state == eState.idle) {
doLog("cancelDiscovery1: abort as state!=idle");
return;
}
doLog("cancelDiscovery1: stutdown ExecutorService");
es.shutdown();
try {
doLog("cancelDiscovery1: waiting for es.shutdown...");
// Wait a while for existing tasks to terminate
if (!es.awaitTermination(60, TimeUnit.SECONDS)) {
es.shutdownNow(); // Cancel currently executing tasks
// Wait a while for tasks to respond to being cancelled
if (!es.awaitTermination(60, TimeUnit.SECONDS))
System.err.println("Pool did not terminate");
}
doLog("cancelDiscovery1: es terminated");
} catch (InterruptedException ie) {
// (Re-)Cancel if current thread also interrupted
doLog("cancelDiscovery1: trying es.shutdownNow...");
es.shutdownNow();
// Preserve interrupt status
doLog("cancelDiscovery1: Preserve interrupt status");
Thread.currentThread().interrupt();
}
doLog("cancelDiscovery1: set state=finished");
// state=eState.finished;
Message msg = mHandler.obtainMessage(msgTypes.finished);
Bundle bundle = new Bundle();
msg.setData(bundle);
mHandler.sendMessage(msg);
state = eState.idle;
doLog("cancelDiscovery1: END");
}
@Override
public void doTraverse(Poset gPoset) {
DefaultPoset poset = (DefaultPoset) gPoset;
@SuppressWarnings("unchecked")
final Queue<VectorClock> ques[] = new Queue[2];
for (int i = 0; i < 2; ++i) ques[i] = new ConcurrentLinkedQueue<VectorClock>();
ques[0].add(new VectorClock(poset.width(), 0));
final AtomicInteger curQue = new AtomicInteger(0);
final CyclicBarrier barrier = new CyclicBarrier(poolSize, new Tripper(ques, curQue));
final ExecutorService pool = Executors.newFixedThreadPool(poolSize);
for (int i = 0; i < poolSize; ++i) {
pool.submit(new Worker(poset, ques, curQue, barrier, enumerator.fork()));
}
pool.shutdown();
try {
if (!pool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS)) {
pool.shutdownNow();
if (!pool.awaitTermination(1, TimeUnit.SECONDS))
logger.error("Thread pool did not terminate.");
}
} catch (InterruptedException e) {
pool.shutdownNow();
logger.warn("Thread pool is forced to shutdown.");
}
}
/** @param pool */
private void shutdownAndAwaitTermination(final ExecutorService pool) {
if (serverSocket != null) {
try {
serverSocket.close();
} catch (IOException e) {
LOG.debug("IO Exception closing server socket", e);
}
}
pool.shutdown(); // Disable new tasks from being submitted
try {
// Cancel currently executing tasks
pool.shutdownNow();
// Wait a while for tasks to respond to being cancelled
if (!pool.awaitTermination(5, TimeUnit.SECONDS)) {
LOG.warn("Federation data channel pool did not terminate");
}
} catch (InterruptedException ie) {
// (Re-)Cancel if current thread also interrupted
pool.shutdownNow();
}
}
protected synchronized void initializeQueue(String host, String queueName, Integer port)
throws InterruptedException {
final String bind = "tcp://" + host + ":" + port;
_log.warn("binding to " + bind);
if (_context == null) {
_context = ZMQ.context(1);
}
if (_socket != null) {
_executorService.shutdownNow();
_heartbeatService.shutdownNow();
Thread.sleep(1 * 1000);
_log.warn("_executorService.isTerminated=" + _executorService.isTerminated());
_socket.close();
_executorService = Executors.newFixedThreadPool(1);
_heartbeatService = Executors.newFixedThreadPool(1);
}
_socket = _context.socket(ZMQ.PUB);
_socket.connect(bind);
_executorService.execute(new SendThread(_socket, queueName));
_heartbeatService.execute(new HeartbeatThread(HEARTBEAT_INTERVAL));
_log.debug("Inference output queue is sending to " + bind);
_initialized = true;
}
public final void a() {
try {
cm.a()
.b()
.a(
"Crashlytics",
(new StringBuilder("Executing shutdown hook for ")).append(a).toString());
b.shutdown();
if (!b.awaitTermination(c, d)) {
cm.a()
.b()
.a(
"Crashlytics",
(new StringBuilder())
.append(a)
.append(
" did not shut down in the allocated time. Requesting immediate shutdown.")
.toString());
b.shutdownNow();
}
return;
} catch (InterruptedException interruptedexception) {
cm.a()
.b()
.a(
"Crashlytics",
String.format(
Locale.US,
"Interrupted while waiting for %s to shut down. Requesting immediate shutdown.",
new Object[] {a}));
}
b.shutdownNow();
}
public static void shutdown() {
logger_.info("Shutting down ...");
synchronized (MessagingService.class) {
/* Stop listening on any socket */
for (SelectionKey skey : listenSockets_.values()) {
SelectorManager.getSelectorManager().cancel(skey);
}
listenSockets_.clear();
/* Shutdown the threads in the EventQueue's */
messageDeserializationExecutor_.shutdownNow();
messageSerializerExecutor_.shutdownNow();
messageDeserializerExecutor_.shutdownNow();
streamExecutor_.shutdownNow();
/* shut down the cachetables */
taskCompletionMap_.shutdown();
callbackMap_.shutdown();
/* Interrupt the selector manager thread */
SelectorManager.getSelectorManager().interrupt();
poolTable_.clear();
verbHandlers_.clear();
bShutdown_ = true;
}
logger_.debug("Shutdown invocation complete.");
}
private void shutdownExecutor(ExecutorService executorService) {
executorService.shutdown();
try {
if (!executorService.awaitTermination(1, TimeUnit.MINUTES)) {
executorService.shutdownNow();
}
} catch (InterruptedException e) {
executorService.shutdownNow();
}
}
@After
public void cleanup() throws InterruptedException {
// env1.shutdown();
// env2.shutdown();
clientPool.shutdownNow();
clientPool.awaitTermination(5, TimeUnit.SECONDS);
serverPool.shutdownNow();
serverPool.awaitTermination(5, TimeUnit.SECONDS);
}
/**
* Stops engine, cancels all running and scheduled display image tasks. Clears internal data. <br>
* <b>NOTE:</b> This method doesn't shutdown {@linkplain
* com.nostra13.universalimageloader.core.ImageLoaderConfiguration.Builder#taskExecutor(java.util.concurrent.Executor)
* custom task executors} if you set them.
*/
void stop() {
if (!configuration.customExecutor) {
((ExecutorService) taskExecutor).shutdownNow();
}
if (!configuration.customExecutorForCachedImages) {
((ExecutorService) taskExecutorForCachedImages).shutdownNow();
}
cacheKeysForImageAwares.clear();
uriLocks.clear();
}
protected void stopThreads() {
if (!mInitialized) {
throw new IllegalArgumentException("Threads already shutdown.");
}
mSendExecutor.shutdown();
mReceiveExecutor.shutdownNow();
mExecutor.shutdownNow();
mSendExecutor = null;
mReceiveExecutor = null;
mExecutor = null;
mInitialized = false;
}
public static void destroy() {
EXECUTOR.shutdown();
try {
if (!EXECUTOR.awaitTermination(1, TimeUnit.SECONDS)) {
EXECUTOR.shutdownNow();
}
} catch (Exception e) {
EXECUTOR.shutdownNow();
Thread.currentThread().interrupt();
}
}
/** 停止任务 */
private void stopTask() {
if (mExecutorService != null) {
mExecutorService.shutdown();
try {
if (!mExecutorService.awaitTermination(60, TimeUnit.SECONDS)) {
mExecutorService.shutdownNow();
if (!mExecutorService.awaitTermination(60, TimeUnit.SECONDS)) {}
}
} catch (InterruptedException ie) {
mExecutorService.shutdownNow();
}
}
}
private void shutdownGracefully(final ExecutorService pool) {
pool.shutdown();
try {
if (pool.awaitTermination(120, TimeUnit.SECONDS)) return;
pool.shutdownNow();
if (pool.awaitTermination(60, TimeUnit.SECONDS)) return;
log.error("Importer pool did not terminate within timeout.");
System.exit(1);
} catch (InterruptedException e) {
pool.shutdownNow();
Thread.currentThread().interrupt();
}
}
public void unInit() {
if (mExecutorService != null) {
mExecutorService.shutdown();
mExecutorService.shutdownNow();
mExecutorService = null;
}
}
public static void shutdown() throws InterruptedException {
excutor.shutdownNow();
while (!excutor.awaitTermination(5, TimeUnit.SECONDS)) {
log.info("await for keyManager shutdown!");
}
log.info("keyManager has shutdown!");
}
public void dispose() {
fireApplicationExiting();
disposeComponents();
ourThreadExecutorsService.shutdownNow();
super.dispose();
}
/**
* Create N VMs using the given cloud provider
*
* @param N
* @param cp
* @return an ordered list with the times necessary to create each VM. If a VM is not created, the
* size of the returned list is less then N.
*/
public List<Long> createVMs(int N, CloudProviderType cpType) {
CloudProvider cp = CloudProviderFactory.getInstance(cpType);
ExecutorService executor = Executors.newFixedThreadPool(N);
List<Future<Long>> futures = new ArrayList<Future<Long>>();
for (int i = 0; i < N; i++) {
Future<Long> future = executor.submit(new VMCreator(cp));
futures.add(future);
awsOneRequestPerSecondRuleSleep(); // EC2 1 second rule
}
Concurrency.waitExecutor(executor, TIMEOUT);
System.out.println("");
List<Long> times = new ArrayList<Long>();
for (Future<Long> f : futures) {
Long time = this.checkFuture(f);
if (time != null) {
times.add(time);
}
}
executor.shutdownNow();
Collections.sort(times);
return times;
}
@Test
public void test10TimesRemoveMessageListener() throws InterruptedException {
ExecutorService ex = Executors.newFixedThreadPool(1);
final CountDownLatch latch = new CountDownLatch(10);
try {
ex.execute(
new Runnable() {
public void run() {
for (int i = 0; i < 10; i++) {
try {
removeMessageListener();
latch.countDown();
} catch (InterruptedException e) {
return;
}
}
}
});
assertTrue(latch.await(30, TimeUnit.SECONDS));
} finally {
ex.shutdownNow();
}
}
@Override
public void onDestroy() {
super.onDestroy();
Log.i(TAG, "Stopping service");
stopForeground(true);
if (acceptor != null) {
try {
acceptor.close();
} catch (IOException e) {
// We don't care
}
}
try {
executor.shutdownNow();
executor.awaitTermination(10, TimeUnit.SECONDS);
} catch (InterruptedException e) {
// Too bad
} finally {
started = false;
// Unfortunately, we have no way to clean up some Binder-based callbacks
// (namely IRotationWatcher) on lower API levels without killing the process,
// which will allow DeathRecipient to handle it on their side.
Process.killProcess(Process.myPid());
}
}
private static boolean getResultWithTimeout(
Callable<Boolean> startBloombergProcess, int timeout, TimeUnit timeUnit) {
ExecutorService executor =
Executors.newSingleThreadExecutor(
new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r, "Bloomberg - bbcomm starter thread");
t.setDaemon(true);
return t;
}
});
Future<Boolean> future = executor.submit(startBloombergProcess);
try {
return future.get(timeout, timeUnit);
} catch (InterruptedException ignore) {
Thread.currentThread().interrupt();
return false;
} catch (ExecutionException | TimeoutException e) {
logger.error("Could not start bbcomm", e);
return false;
} finally {
executor.shutdownNow();
try {
if (!executor.awaitTermination(100, TimeUnit.MILLISECONDS)) {
logger.warn("bbcomm starter thread still running");
}
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
}
}
private void doShutdownExecutorService(ExecutorService executorService) {
if (this.shutdownForced) {
executorService.shutdownNow();
} else {
executorService.shutdown();
}
}
private Pair<Map<String, String>, /*was it created now?*/ Boolean> getOrCreateIndexConfig(
Class<? extends PropertyContainer> cls,
String indexName,
Map<String, String> suppliedConfig) {
Pair<Map<String, String>, Boolean> result =
findIndexConfig(cls, indexName, suppliedConfig, config.getParams());
boolean createdNow = false;
if (result.other()) { // Ok, we need to create this config
synchronized (this) { // Were we the first ones to get here?
Map<String, String> existing = indexStore.get(cls, indexName);
if (existing != null) {
// No, someone else made it before us, cool
assertConfigMatches(
getIndexProvider(existing.get(PROVIDER)), indexName, existing, result.first());
return Pair.of(result.first(), false);
}
// We were the first one here, let's create this config
ExecutorService executorService = Executors.newSingleThreadExecutor();
try {
executorService.submit(new IndexCreatorJob(cls, indexName, result.first())).get();
indexStore.set(cls, indexName, result.first());
createdNow = true;
} catch (ExecutionException ex) {
throw new TransactionFailureException(
"Index creation failed for " + indexName + ", " + result.first(), ex.getCause());
} catch (InterruptedException ex) {
Thread.interrupted();
} finally {
executorService.shutdownNow();
}
}
}
return Pair.of(result.first(), createdNow);
}
/** Closes resources. */
@Override
public void close() {
if (closed.compareAndSet(false, true) && numThreads > 0) {
LOG.log(Level.FINEST, "Closing ThreadPoolStage {0}: begin", this.name);
executor.shutdown();
boolean isTerminated = false;
try {
isTerminated = executor.awaitTermination(SHUTDOWN_TIMEOUT, TimeUnit.MILLISECONDS);
} catch (final InterruptedException ex) {
LOG.log(Level.WARNING, "Interrupted closing ThreadPoolStage " + this.name, ex);
}
if (!isTerminated) {
final List<Runnable> droppedRunnables = executor.shutdownNow();
LOG.log(
Level.SEVERE,
"Closing ThreadPoolStage {0}: Executor did not terminate in {1} ms. Dropping {2} tasks",
new Object[] {this.name, SHUTDOWN_TIMEOUT, droppedRunnables.size()});
}
LOG.log(Level.FINEST, "Closing ThreadPoolStage {0}: end", this.name);
}
}
public static void main(String[] args) {
ExecutorService threadPool = Executors.newSingleThreadExecutor();
Future<Integer> future =
threadPool.submit(
new Callable<Integer>() {
public Integer call() throws Exception {
while (!Thread.interrupted()) {
Thread.sleep(1000); // 必须要有，不然cancel方法无效
System.out.println("call");
}
return 0;
}
});
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// threadPool.shutdown(); // 不会停止
threadPool.shutdownNow();
// future.cancel(true); // 停止
}
private HttpResponse executeRequest(
final Callable<HttpResponse> task, final long timeout, final TimeUnit unit)
throws TimeoutException, IOException {
ExecutorService executor = Executors.newSingleThreadExecutor();
try {
Throwable lastCause = null;
long endTime = System.currentTimeMillis() + unit.toMillis(timeout);
while (System.currentTimeMillis() < endTime) {
Future<HttpResponse> result = executor.submit(task);
try {
return result.get(timeout, unit);
} catch (InterruptedException ex) {
throw new IllegalStateException(ex);
} catch (ExecutionException ex) {
lastCause = ex.getCause();
// HttpURLConnection throws FileNotFoundException on 404 so handle this
if (lastCause instanceof FileNotFoundException) {
HttpResponse httpResult = new HttpResponse();
httpResult.setStatusCode(HttpURLConnection.HTTP_NOT_FOUND);
return httpResult;
} else {
continue;
}
}
}
TimeoutException toex = new TimeoutException();
if (lastCause != null) {
toex.initCause(lastCause);
}
throw toex;
} finally {
executor.shutdownNow();
}
}
public void stop() throws IOException {
listenerServer.stop();
messageReceiver.close(false);
if (!executorService.isShutdown()) {
executorService.shutdownNow();
}
}
public static void main(String[] args) {
final BlockingQueue<Character> bq;
bq = new ArrayBlockingQueue<Character>(26);
final ExecutorService executor = Executors.newFixedThreadPool(2);
Runnable producer =
() -> {
for (char ch = 'A'; ch <= 'Z'; ch++) {
try {
bq.put(ch);
System.out.printf("%c produced by " + "producer.%n", ch);
} catch (InterruptedException ie) {
}
}
};
executor.execute(producer);
Runnable consumer =
() -> {
char ch = '\0';
do {
try {
ch = bq.take();
System.out.printf("%c consumed by " + "consumer.%n", ch);
} catch (InterruptedException ie) {
}
} while (ch != 'Z');
executor.shutdownNow();
};
executor.execute(consumer);
}
@Test
public void testFlush() throws Exception {
final int registerCount = 1000;
ExecutorService pool = Executors.newCachedThreadPool();
try {
final HeapSizeManager underTest = new HeapSizeManager(100l, 100);
final AtomicBoolean allOperationsDone = new AtomicBoolean();
final LinkedBlockingQueue<Long> registeredEvents = new LinkedBlockingQueue<>();
Future<?> writeFuture =
pool.submit(
new Runnable() {
@Override
public void run() {
try {
for (int i = 0; i < registerCount; i++) {
registeredEvents.offer(underTest.registerOperationWithHeapSize(1));
}
underTest.flush();
allOperationsDone.set(true);
synchronized (allOperationsDone) {
allOperationsDone.notify();
}
} catch (InterruptedException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
});
Thread.sleep(100);
Future<?> readFuture =
pool.submit(
new Runnable() {
@Override
public void run() {
try {
for (int i = 0; i < registerCount; i++) {
Long registeredId = registeredEvents.poll(1, TimeUnit.SECONDS);
if (registeredId == null) {
i--;
} else {
if (i % 50 == 0) {
// Exercise the .offer and the flush() in the writeFuture.
Thread.sleep(40);
}
underTest.markCanBeCompleted(registeredId);
}
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
readFuture.get(30, TimeUnit.SECONDS);
writeFuture.get(30, TimeUnit.SECONDS);
assertTrue(allOperationsDone.get());
} finally {
pool.shutdownNow();
}
}