下面列出了java.util.concurrent.Future#isCancelled ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private void moreDataAvailable()
{
final Future<?> future = this.future;
if (future == null || future.isDone() || future.isCancelled()) {
// Do not schedule a new task if there is an existing one that is still running or is waiting in the queue
this.future = autoFlushExecutor.submit(this);
} else {
synchronized (this) {
if (this.future == null) {
// future is set to null before run() exists, no need to check whether future isDone() or isCancelled()
this.future = autoFlushExecutor.submit(this);
} else {
isMoreDataAvailable = true;
}
}
}
}
private static void printResults(List<Future<Result>> futures, int timeoutSec) {
System.out.println("Results from futures:");
if (futures == null || futures.size() == 0) {
System.out.println("No results. Futures" + (futures == null ? " = null" : ".size()=0"));
} else {
for (Future<Result> future : futures) {
try {
if (future.isCancelled()) {
System.out.println("Worker is cancelled.");
} else {
Result result = future.get(timeoutSec, TimeUnit.SECONDS);
System.out.println("Worker " + result.getWorkerName() + " slept "
+ result.getSleepSec() + " sec. Result = " + result.getResult());
}
} catch (Exception ex) {
System.out.println("Caught while getting result: " + ex.getClass().getName());
}
}
}
}
@Override
protected void afterExecute(final Runnable r, Throwable t) {
super.afterExecute(r, t);
if (t == null && r instanceof Future<?>) {
try {
final Future<?> future = (Future<?>) r;
if (future.isDone() && !future.isCancelled()) {
future.get();
}
} catch (final CancellationException ce) {
t = ce;
} catch (final ExecutionException ee) {
t = ee.getCause();
} catch (final InterruptedException ie) {
Thread.currentThread().interrupt();
}
}
if (t != null) {
t.printStackTrace();
}
}
void start()
{
for (Processor processor : processors) {
for (int i = 0; i < processor.getParallelism(); i++) {
RunningProcessor runningProcessor = new RunningProcessor(processor);
futures.add(executorService.submit(runningProcessor));
runningProcessors.add(runningProcessor);
}
}
logger.info("Loading pipeline started.");
int finishedProcessors = 0;
while (finishedProcessors < futures.size()) {
for (Future future : futures) {
if (future.isDone() || future.isCancelled()) {
try {
future.get();
}
catch (InterruptedException | ExecutionException e) {
// todo deal with execution exceptions
e.printStackTrace();
}
finishedProcessors++;
}
}
}
}
/** Abort scan
* @param previous Previous state from `prepareAbort()`
*/
public void doAbort(final ScanState previous)
{
if (previous.isDone())
return;
logger.log(Level.INFO, "Abort " + this + " (" + previous + ")");
// Interrupt, except when already aborted, failed, ..
// to prevent interruption when in the middle of updating scan state PVs
final Future<Object> save = future.orElse(null);
if (save != null && ! save.isCancelled())
{
final boolean interrupt = previous == ScanState.Idle ||
previous == ScanState.Running ||
previous == ScanState.Paused;
save.cancel(interrupt);
if (interrupt)
logger.log(Level.INFO, "Interrupted " + this);
else
logger.log(Level.INFO, "Cancelled " + this);
}
synchronized (this)
{
notifyAll();
}
}
private static void demo1_Executor1() {
System.out.println();
int shutdownDelaySec = 1;
ExecutorService execService = Executors.newSingleThreadExecutor();
Runnable runnable = () -> System.out.println("Worker One did the job.");
execService.execute(runnable);
runnable = () -> System.out.println("Worker Two did the job.");
Future future = execService.submit(runnable);
try {
execService.shutdown();
execService.awaitTermination(shutdownDelaySec, TimeUnit.SECONDS);
} catch (Exception ex) {
System.out.println("Caught around execService.awaitTermination(): " + ex.getClass().getName());
} finally {
if (!execService.isTerminated()) {
if (future != null && !future.isDone() && !future.isCancelled()) {
System.out.println("Cancelling the task...");
future.cancel(true);
}
}
List<Runnable> l = execService.shutdownNow();
System.out.println(l.size() + " tasks were waiting to be executed. Service stopped.");
}
}
private static void shutdownAndCancelTask(ExecutorService execService, int shutdownDelaySec, String name, Future future) {
try {
execService.shutdown();
System.out.println("Waiting for " + shutdownDelaySec + " sec before shutting down service...");
execService.awaitTermination(shutdownDelaySec, TimeUnit.SECONDS);
} catch (Exception ex) {
System.out.println("Caught around execService.awaitTermination(): " + ex.getClass().getName());
} finally {
if (!execService.isTerminated()) {
System.out.println("Terminating remaining running tasks...");
if (future != null && !future.isDone() && !future.isCancelled()) {
System.out.println("Cancelling task " + name + "...");
future.cancel(true);
}
}
System.out.println("Calling execService.shutdownNow()...");
List<Runnable> l = execService.shutdownNow();
System.out.println(l.size() + " tasks were waiting to be executed. Service stopped.");
}
}
private static void shutdownAndCancelTasks(ExecutorService execService, int shutdownDelaySec, List<Future<Result>> futures) {
try {
execService.shutdown();
System.out.println("Waiting for " + shutdownDelaySec + " sec before shutting down service...");
execService.awaitTermination(shutdownDelaySec, TimeUnit.SECONDS);
} catch (Exception ex) {
System.out.println("Caught around execService.awaitTermination(): " + ex.getClass().getName());
} finally {
if (!execService.isTerminated()) {
System.out.println("Terminating remaining running tasks...");
for (Future<Result> future : futures) {
if (future.isDone() && !future.isCancelled()) {
System.out.println("Cancelling task...");
future.cancel(true);
}
}
}
System.out.println("Calling execService.shutdownNow()...");
List<Runnable> l = execService.shutdownNow();
System.out.println(l.size() + " tasks were waiting to be executed. Service stopped.");
}
}
private static void shutdownAndCancelTask(ExecutorService execService, int shutdownDelaySec, String name, Future future) {
try {
execService.shutdown();
System.out.println("Waiting for " + shutdownDelaySec + " sec before shutting down service...");
execService.awaitTermination(shutdownDelaySec, TimeUnit.SECONDS);
} catch (Exception ex) {
System.out.println("Caught around execService.awaitTermination(): " + ex.getClass().getName());
} finally {
if (!execService.isTerminated()) {
System.out.println("Terminating remaining running tasks...");
if (future != null && !future.isDone() && !future.isCancelled()) {
System.out.println("Cancelling task " + name + "...");
future.cancel(true);
}
}
System.out.println("Calling execService.shutdownNow()...");
List<Runnable> l = execService.shutdownNow();
System.out.println(l.size() + " tasks were waiting to be executed. Service stopped.");
}
}
private static void demo1_Executor1() {
System.out.println();
int shutdownDelaySec = 1;
ExecutorService execService = Executors.newSingleThreadExecutor();
Runnable runnable = () -> System.out.println("Worker One did the job.");
execService.execute(runnable);
runnable = () -> System.out.println("Worker Two did the job.");
Future future = execService.submit(runnable);
try {
execService.shutdown();
execService.awaitTermination(shutdownDelaySec, TimeUnit.SECONDS);
} catch (Exception ex) {
System.out.println("Caught around execService.awaitTermination(): " + ex.getClass().getName());
} finally {
if (!execService.isTerminated()) {
if (future != null && !future.isDone() && !future.isCancelled()) {
System.out.println("Cancelling the task...");
future.cancel(true);
}
}
List<Runnable> l = execService.shutdownNow();
System.out.println(l.size() + " tasks were waiting to be executed. Service stopped.");
}
}
public static void demoFutureWithCallable() throws InterruptedException, ExecutionException {
System.out.println();
System.out.println("Demo Future with Callable");
ExecutorService pool = Executors.newCachedThreadPool();
Future<Pizza> pizzaPickupOrder = pool.submit(() -> {
System.out.println(" Restaurant> Slicing tomatoes");
System.out.println(" Restaurant> Chopping onions");
System.out.println(" Restaurant> Spreading with tomato sauce and sprinkle with toppings");
System.out.println(" Restaurant> Baking pizza");
TimeUnit.MILLISECONDS.sleep(300);
return new Pizza();
});
System.out.println("Me: Call my brother");
TimeUnit.MILLISECONDS.sleep(200);
System.out.println("Me: Walk the dog");
// Try this: pizzaPickupOrder.cancel(true);
if (pizzaPickupOrder.isCancelled()) {
System.out.println("Me: pizza is cancelled, order something else");
System.out.println("pizzaPickupOrder.isDone(): " + pizzaPickupOrder.isDone());
} else if (!pizzaPickupOrder.isDone()) {
System.out.println("Me: Watch a TV show");
}
Pizza pizza = pizzaPickupOrder.get();
System.out.println("Me: Eat the pizza: " + pizza);
pool.shutdown();
System.out.println();
System.out.println();
}
/**
* 多个异步执行
*
* @param
* @return java.lang.String
* @throws
* @author wliduo[[email protected]]
* @date 2020/5/20 10:26
*/
@GetMapping("/run3")
public String run3() throws Exception {
logger.info("run3开始执行");
long start = System.currentTimeMillis();
Future<String> future3 = asyncService.task3();
Future<String> future4 = asyncService.task4();
// 这样与下面是一样的
logger.info(future3.get());
logger.info(future4.get());
// 先判断是否执行完成
boolean run3Done = Boolean.FALSE;
while (true) {
if (future3.isDone() && future4.isDone()) {
// 执行完成
run3Done = Boolean.TRUE;
break;
}
if (future3.isCancelled() || future4.isCancelled()) {
// 取消情况
break;
}
}
if (run3Done) {
logger.info(future3.get());
logger.info(future4.get());
} else {
// 其他异常情况
}
long end = System.currentTimeMillis();
logger.info("run3执行完成，执行时间: {}", end - start);
return "run3 success";
}
private void waitForRunningQueuesToStop() {
for (Map.Entry<String, Boolean> runningState : queueRunningState.entrySet()) {
String queueName = runningState.getKey();
ScheduledTaskDetail scheduledTaskDetail = queueNameToScheduledTask.get(queueName);
if (scheduledTaskDetail != null) {
Future<?> future = scheduledTaskDetail.getFuture();
boolean completedOrCancelled = future.isCancelled() || future.isDone();
if (!completedOrCancelled) {
future.cancel(true);
}
}
}
}
/**
* Count the number of active sub tasks.
*/
public synchronized int numActiveSubTasks() {
int c = 0;
for (Future<?> f : subTasks) {
if (!f.isDone() && !f.isCancelled()) {
c++;
}
}
return c;
}
/**
* Count the number of active sub tasks.
*/
public synchronized int numActiveSubTasks() {
int c = 0;
for (Future<?> f : subTasks) {
if (!f.isDone() && !f.isCancelled()) {
c++;
}
}
return c;
}
void assertCancelled(Future<?> future) throws Exception {
if (!future.isDone())
throw new AssertionError("not done");
if (!future.isCancelled())
throw new AssertionError("not cancelled");
try {
future.get(LONG_DELAY_MS, MILLISECONDS);
throw new AssertionError("should throw CancellationException");
} catch (CancellationException success) {}
}
@Override
public void interruptImmediately() {
super.interruptImmediately();
if (tasks != null && tasks.length > 0) {
synchronized (tasks) {
for (int index = 0; index < tasks.length; index++) {
Future task = tasks[index];
if (task != null && !task.isDone() && !task.isCancelled()) {
task.cancel(true);
}
}
}
}
}
private void resultScript(Map<Long, Future<Exception>> runningScriptMap) throws InterruptedException {
Iterator<Entry<Long, Future<Exception>>> iterator = runningScriptMap.entrySet().iterator();
while (iterator.hasNext()) {
Entry<Long, Future<Exception>> scriptFeature = iterator.next();
Future<Exception> future = scriptFeature.getValue();
if (future.isDone()) {
iterator.remove();
Long currentTestScript = scriptFeature.getKey();
TestScriptDescription descr = testScripts.get(currentTestScript);
unlockServices(descr);
Throwable result;
try {
result = future.get();
} catch (Exception e) {
logger.warn("Interrupt of matrix execution, reason : {}", e.getMessage(), e);
result = e;
}
if (future.isCancelled()) {
descr.scriptInterrupted();
} else if (result != null) {
descr.scriptRunFailed(result);
} else {
descr.scriptExecuted();
}
onRunFinished(descr);
logger.info("TestScript {} was executed", currentTestScript);
}
}
}
@Override
public Func<String, Response> apply(final String group,
final String artifact) throws IOException {
final Future<Func<String, Response>> future = new IoCheckedBiFunc<>(
this.cache
).apply(group, artifact);
final Func<String, Response> output;
if (future.isCancelled()) {
output = input -> new RsPage(
new RqFake(),
"error",
() -> new IterableOf<>(
new XeAppend("group", group),
new XeAppend("artifact", artifact),
new XeAppend("future", future.toString())
)
);
} else if (future.isDone()) {
try {
output = future.get();
} catch (final InterruptedException | ExecutionException ex) {
throw new IllegalStateException(ex);
}
} else {
final long msec = System.currentTimeMillis()
- this.starts.computeIfAbsent(
String.format("%s:%s", group, artifact),
s -> System.currentTimeMillis()
);
output = input -> new RsWithStatus(
new RsPage(
new RqFake(),
"wait",
() -> new IterableOf<>(
new XeAppend("group", group),
new XeAppend("artifact", artifact),
new XeAppend("future", future.toString()),
new XeAppend("msec", Long.toString(msec)),
new XeAppend(
"spent",
Logger.format("%[ms]s", msec)
)
)
),
HttpURLConnection.HTTP_NOT_FOUND
);
}
return output;
}
private boolean cancelTimeoutTask(Branch branch) {
Future timeoutTaskFuture = branch.getTimeoutTaskFuture();
return Objects.isNull(timeoutTaskFuture)
|| timeoutTaskFuture.isCancelled()
|| timeoutTaskFuture.cancel(false);
}