001/* 002 * Copyright (C) 2011 The Guava Authors 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except 005 * in compliance with the License. You may obtain a copy of the License at 006 * 007 * http://www.apache.org/licenses/LICENSE-2.0 008 * 009 * Unless required by applicable law or agreed to in writing, software distributed under the License 010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 011 * or implied. See the License for the specific language governing permissions and limitations under 012 * the License. 013 */ 014 015package com.google.common.util.concurrent; 016 017import static com.google.common.base.Preconditions.checkArgument; 018import static com.google.common.base.Preconditions.checkNotNull; 019import static com.google.common.util.concurrent.Futures.immediateCancelledFuture; 020import static com.google.common.util.concurrent.Internal.toNanosSaturated; 021import static com.google.common.util.concurrent.MoreExecutors.directExecutor; 022import static com.google.common.util.concurrent.Platform.restoreInterruptIfIsInterruptedException; 023import static java.util.Objects.requireNonNull; 024import static java.util.concurrent.TimeUnit.NANOSECONDS; 025 026import com.google.common.annotations.GwtIncompatible; 027import com.google.common.annotations.J2ktIncompatible; 028import com.google.errorprone.annotations.CanIgnoreReturnValue; 029import com.google.errorprone.annotations.concurrent.GuardedBy; 030import com.google.j2objc.annotations.WeakOuter; 031import java.time.Duration; 032import java.util.concurrent.Callable; 033import java.util.concurrent.Executor; 034import java.util.concurrent.Executors; 035import java.util.concurrent.Future; 036import java.util.concurrent.ScheduledExecutorService; 037import java.util.concurrent.ScheduledFuture; 038import java.util.concurrent.ThreadFactory; 039import java.util.concurrent.TimeUnit; 040import java.util.concurrent.TimeoutException; 041import java.util.concurrent.locks.ReentrantLock; 042import java.util.logging.Level; 043import javax.annotation.CheckForNull; 044import org.checkerframework.checker.nullness.qual.Nullable; 045 046/** 047 * Base class for services that can implement {@link #startUp} and {@link #shutDown} but while in 048 * the "running" state need to perform a periodic task. Subclasses can implement {@link #startUp}, 049 * {@link #shutDown} and also a {@link #runOneIteration} method that will be executed periodically. 050 * 051 * <p>This class uses the {@link ScheduledExecutorService} returned from {@link #executor} to run 052 * the {@link #startUp} and {@link #shutDown} methods and also uses that service to schedule the 053 * {@link #runOneIteration} that will be executed periodically as specified by its {@link 054 * Scheduler}. When this service is asked to stop via {@link #stopAsync} it will cancel the periodic 055 * task (but not interrupt it) and wait for it to stop before running the {@link #shutDown} method. 056 * 057 * <p>Subclasses are guaranteed that the life cycle methods ({@link #runOneIteration}, {@link 058 * #startUp} and {@link #shutDown}) will never run concurrently. Notably, if any execution of {@link 059 * #runOneIteration} takes longer than its schedule defines, then subsequent executions may start 060 * late. Also, all life cycle methods are executed with a lock held, so subclasses can safely modify 061 * shared state without additional synchronization necessary for visibility to later executions of 062 * the life cycle methods. 063 * 064 * <h3>Usage Example</h3> 065 * 066 * <p>Here is a sketch of a service which crawls a website and uses the scheduling capabilities to 067 * rate limit itself. 068 * 069 * <pre>{@code 070 * class CrawlingService extends AbstractScheduledService { 071 * private Set<Uri> visited; 072 * private Queue<Uri> toCrawl; 073 * protected void startUp() throws Exception { 074 * toCrawl = readStartingUris(); 075 * } 076 * 077 * protected void runOneIteration() throws Exception { 078 * Uri uri = toCrawl.remove(); 079 * Collection<Uri> newUris = crawl(uri); 080 * visited.add(uri); 081 * for (Uri newUri : newUris) { 082 * if (!visited.contains(newUri)) { toCrawl.add(newUri); } 083 * } 084 * } 085 * 086 * protected void shutDown() throws Exception { 087 * saveUris(toCrawl); 088 * } 089 * 090 * protected Scheduler scheduler() { 091 * return Scheduler.newFixedRateSchedule(0, 1, TimeUnit.SECONDS); 092 * } 093 * } 094 * }</pre> 095 * 096 * <p>This class uses the life cycle methods to read in a list of starting URIs and save the set of 097 * outstanding URIs when shutting down. Also, it takes advantage of the scheduling functionality to 098 * rate limit the number of queries we perform. 099 * 100 * @author Luke Sandberg 101 * @since 11.0 102 */ 103@GwtIncompatible 104@J2ktIncompatible 105@ElementTypesAreNonnullByDefault 106public abstract class AbstractScheduledService implements Service { 107 private static final LazyLogger logger = new LazyLogger(AbstractScheduledService.class); 108 109 /** 110 * A scheduler defines the policy for how the {@link AbstractScheduledService} should run its 111 * task. 112 * 113 * <p>Consider using the {@link #newFixedDelaySchedule} and {@link #newFixedRateSchedule} factory 114 * methods, these provide {@link Scheduler} instances for the common use case of running the 115 * service with a fixed schedule. If more flexibility is needed then consider subclassing {@link 116 * CustomScheduler}. 117 * 118 * @author Luke Sandberg 119 * @since 11.0 120 */ 121 public abstract static class Scheduler { 122 /** 123 * Returns a {@link Scheduler} that schedules the task using the {@link 124 * ScheduledExecutorService#scheduleWithFixedDelay} method. 125 * 126 * @param initialDelay the time to delay first execution 127 * @param delay the delay between the termination of one execution and the commencement of the 128 * next 129 * @since 28.0 130 */ 131 public static Scheduler newFixedDelaySchedule(Duration initialDelay, Duration delay) { 132 return newFixedDelaySchedule( 133 toNanosSaturated(initialDelay), toNanosSaturated(delay), NANOSECONDS); 134 } 135 136 /** 137 * Returns a {@link Scheduler} that schedules the task using the {@link 138 * ScheduledExecutorService#scheduleWithFixedDelay} method. 139 * 140 * @param initialDelay the time to delay first execution 141 * @param delay the delay between the termination of one execution and the commencement of the 142 * next 143 * @param unit the time unit of the initialDelay and delay parameters 144 */ 145 @SuppressWarnings("GoodTime") // should accept a java.time.Duration 146 public static Scheduler newFixedDelaySchedule( 147 final long initialDelay, final long delay, final TimeUnit unit) { 148 checkNotNull(unit); 149 checkArgument(delay > 0, "delay must be > 0, found %s", delay); 150 return new Scheduler() { 151 @Override 152 public Cancellable schedule( 153 AbstractService service, ScheduledExecutorService executor, Runnable task) { 154 return new FutureAsCancellable( 155 executor.scheduleWithFixedDelay(task, initialDelay, delay, unit)); 156 } 157 }; 158 } 159 160 /** 161 * Returns a {@link Scheduler} that schedules the task using the {@link 162 * ScheduledExecutorService#scheduleAtFixedRate} method. 163 * 164 * @param initialDelay the time to delay first execution 165 * @param period the period between successive executions of the task 166 * @since 28.0 167 */ 168 public static Scheduler newFixedRateSchedule(Duration initialDelay, Duration period) { 169 return newFixedRateSchedule( 170 toNanosSaturated(initialDelay), toNanosSaturated(period), NANOSECONDS); 171 } 172 173 /** 174 * Returns a {@link Scheduler} that schedules the task using the {@link 175 * ScheduledExecutorService#scheduleAtFixedRate} method. 176 * 177 * @param initialDelay the time to delay first execution 178 * @param period the period between successive executions of the task 179 * @param unit the time unit of the initialDelay and period parameters 180 */ 181 @SuppressWarnings("GoodTime") // should accept a java.time.Duration 182 public static Scheduler newFixedRateSchedule( 183 final long initialDelay, final long period, final TimeUnit unit) { 184 checkNotNull(unit); 185 checkArgument(period > 0, "period must be > 0, found %s", period); 186 return new Scheduler() { 187 @Override 188 public Cancellable schedule( 189 AbstractService service, ScheduledExecutorService executor, Runnable task) { 190 return new FutureAsCancellable( 191 executor.scheduleAtFixedRate(task, initialDelay, period, unit)); 192 } 193 }; 194 } 195 196 /** Schedules the task to run on the provided executor on behalf of the service. */ 197 abstract Cancellable schedule( 198 AbstractService service, ScheduledExecutorService executor, Runnable runnable); 199 200 private Scheduler() {} 201 } 202 203 /* use AbstractService for state management */ 204 private final AbstractService delegate = new ServiceDelegate(); 205 206 @WeakOuter 207 private final class ServiceDelegate extends AbstractService { 208 209 // A handle to the running task so that we can stop it when a shutdown has been requested. 210 // These two fields are volatile because their values will be accessed from multiple threads. 211 @CheckForNull private volatile Cancellable runningTask; 212 @CheckForNull private volatile ScheduledExecutorService executorService; 213 214 // This lock protects the task so we can ensure that none of the template methods (startUp, 215 // shutDown or runOneIteration) run concurrently with one another. 216 // TODO(lukes): why don't we use ListenableFuture to sequence things? Then we could drop the 217 // lock. 218 private final ReentrantLock lock = new ReentrantLock(); 219 220 @WeakOuter 221 class Task implements Runnable { 222 @Override 223 public void run() { 224 lock.lock(); 225 try { 226 /* 227 * requireNonNull is safe because Task isn't run (or at least it doesn't succeed in taking 228 * the lock) until after it's scheduled and the runningTask field is set. 229 */ 230 if (requireNonNull(runningTask).isCancelled()) { 231 // task may have been cancelled while blocked on the lock. 232 return; 233 } 234 AbstractScheduledService.this.runOneIteration(); 235 } catch (Throwable t) { 236 restoreInterruptIfIsInterruptedException(t); 237 try { 238 shutDown(); 239 } catch (Exception ignored) { 240 restoreInterruptIfIsInterruptedException(ignored); 241 logger 242 .get() 243 .log( 244 Level.WARNING, 245 "Error while attempting to shut down the service after failure.", 246 ignored); 247 } 248 notifyFailed(t); 249 // requireNonNull is safe now, just as it was above. 250 requireNonNull(runningTask).cancel(false); // prevent future invocations. 251 } finally { 252 lock.unlock(); 253 } 254 } 255 } 256 257 private final Runnable task = new Task(); 258 259 @Override 260 protected final void doStart() { 261 executorService = 262 MoreExecutors.renamingDecorator(executor(), () -> serviceName() + " " + state()); 263 executorService.execute( 264 () -> { 265 lock.lock(); 266 try { 267 startUp(); 268 /* 269 * requireNonNull is safe because executorService is never cleared after the 270 * assignment above. 271 */ 272 requireNonNull(executorService); 273 runningTask = scheduler().schedule(delegate, executorService, task); 274 notifyStarted(); 275 } catch (Throwable t) { 276 restoreInterruptIfIsInterruptedException(t); 277 notifyFailed(t); 278 if (runningTask != null) { 279 // prevent the task from running if possible 280 runningTask.cancel(false); 281 } 282 } finally { 283 lock.unlock(); 284 } 285 }); 286 } 287 288 @Override 289 protected final void doStop() { 290 // Both requireNonNull calls are safe because doStop can run only after a successful doStart. 291 requireNonNull(runningTask); 292 requireNonNull(executorService); 293 runningTask.cancel(false); 294 executorService.execute( 295 () -> { 296 try { 297 lock.lock(); 298 try { 299 if (state() != State.STOPPING) { 300 // This means that the state has changed since we were scheduled. This implies 301 // that an execution of runOneIteration has thrown an exception and we have 302 // transitioned to a failed state, also this means that shutDown has already 303 // been called, so we do not want to call it again. 304 return; 305 } 306 shutDown(); 307 } finally { 308 lock.unlock(); 309 } 310 notifyStopped(); 311 } catch (Throwable t) { 312 restoreInterruptIfIsInterruptedException(t); 313 notifyFailed(t); 314 } 315 }); 316 } 317 318 @Override 319 public String toString() { 320 return AbstractScheduledService.this.toString(); 321 } 322 } 323 324 /** Constructor for use by subclasses. */ 325 protected AbstractScheduledService() {} 326 327 /** 328 * Run one iteration of the scheduled task. If any invocation of this method throws an exception, 329 * the service will transition to the {@link Service.State#FAILED} state and this method will no 330 * longer be called. 331 */ 332 protected abstract void runOneIteration() throws Exception; 333 334 /** 335 * Start the service. 336 * 337 * <p>By default this method does nothing. 338 */ 339 protected void startUp() throws Exception {} 340 341 /** 342 * Stop the service. This is guaranteed not to run concurrently with {@link #runOneIteration}. 343 * 344 * <p>By default this method does nothing. 345 */ 346 protected void shutDown() throws Exception {} 347 348 /** 349 * Returns the {@link Scheduler} object used to configure this service. This method will only be 350 * called once. 351 */ 352 // TODO(cpovirk): @ForOverride 353 protected abstract Scheduler scheduler(); 354 355 /** 356 * Returns the {@link ScheduledExecutorService} that will be used to execute the {@link #startUp}, 357 * {@link #runOneIteration} and {@link #shutDown} methods. If this method is overridden the 358 * executor will not be {@linkplain ScheduledExecutorService#shutdown shutdown} when this service 359 * {@linkplain Service.State#TERMINATED terminates} or {@linkplain Service.State#TERMINATED 360 * fails}. Subclasses may override this method to supply a custom {@link ScheduledExecutorService} 361 * instance. This method is guaranteed to only be called once. 362 * 363 * <p>By default this returns a new {@link ScheduledExecutorService} with a single thread pool 364 * that sets the name of the thread to the {@linkplain #serviceName() service name}. Also, the 365 * pool will be {@linkplain ScheduledExecutorService#shutdown() shut down} when the service 366 * {@linkplain Service.State#TERMINATED terminates} or {@linkplain Service.State#TERMINATED 367 * fails}. 368 */ 369 protected ScheduledExecutorService executor() { 370 @WeakOuter 371 class ThreadFactoryImpl implements ThreadFactory { 372 @Override 373 public Thread newThread(Runnable runnable) { 374 return MoreExecutors.newThread(serviceName(), runnable); 375 } 376 } 377 final ScheduledExecutorService executor = 378 Executors.newSingleThreadScheduledExecutor(new ThreadFactoryImpl()); 379 // Add a listener to shut down the executor after the service is stopped. This ensures that the 380 // JVM shutdown will not be prevented from exiting after this service has stopped or failed. 381 // Technically this listener is added after start() was called so it is a little gross, but it 382 // is called within doStart() so we know that the service cannot terminate or fail concurrently 383 // with adding this listener so it is impossible to miss an event that we are interested in. 384 addListener( 385 new Listener() { 386 @Override 387 public void terminated(State from) { 388 executor.shutdown(); 389 } 390 391 @Override 392 public void failed(State from, Throwable failure) { 393 executor.shutdown(); 394 } 395 }, 396 directExecutor()); 397 return executor; 398 } 399 400 /** 401 * Returns the name of this service. {@link AbstractScheduledService} may include the name in 402 * debugging output. 403 * 404 * @since 14.0 405 */ 406 protected String serviceName() { 407 return getClass().getSimpleName(); 408 } 409 410 @Override 411 public String toString() { 412 return serviceName() + " [" + state() + "]"; 413 } 414 415 @Override 416 public final boolean isRunning() { 417 return delegate.isRunning(); 418 } 419 420 @Override 421 public final State state() { 422 return delegate.state(); 423 } 424 425 /** @since 13.0 */ 426 @Override 427 public final void addListener(Listener listener, Executor executor) { 428 delegate.addListener(listener, executor); 429 } 430 431 /** @since 14.0 */ 432 @Override 433 public final Throwable failureCause() { 434 return delegate.failureCause(); 435 } 436 437 /** @since 15.0 */ 438 @CanIgnoreReturnValue 439 @Override 440 public final Service startAsync() { 441 delegate.startAsync(); 442 return this; 443 } 444 445 /** @since 15.0 */ 446 @CanIgnoreReturnValue 447 @Override 448 public final Service stopAsync() { 449 delegate.stopAsync(); 450 return this; 451 } 452 453 /** @since 15.0 */ 454 @Override 455 public final void awaitRunning() { 456 delegate.awaitRunning(); 457 } 458 459 /** @since 28.0 */ 460 @Override 461 public final void awaitRunning(Duration timeout) throws TimeoutException { 462 Service.super.awaitRunning(timeout); 463 } 464 465 /** @since 15.0 */ 466 @Override 467 public final void awaitRunning(long timeout, TimeUnit unit) throws TimeoutException { 468 delegate.awaitRunning(timeout, unit); 469 } 470 471 /** @since 15.0 */ 472 @Override 473 public final void awaitTerminated() { 474 delegate.awaitTerminated(); 475 } 476 477 /** @since 28.0 */ 478 @Override 479 public final void awaitTerminated(Duration timeout) throws TimeoutException { 480 Service.super.awaitTerminated(timeout); 481 } 482 483 /** @since 15.0 */ 484 @Override 485 public final void awaitTerminated(long timeout, TimeUnit unit) throws TimeoutException { 486 delegate.awaitTerminated(timeout, unit); 487 } 488 489 interface Cancellable { 490 void cancel(boolean mayInterruptIfRunning); 491 492 boolean isCancelled(); 493 } 494 495 private static final class FutureAsCancellable implements Cancellable { 496 private final Future<?> delegate; 497 498 FutureAsCancellable(Future<?> delegate) { 499 this.delegate = delegate; 500 } 501 502 @Override 503 public void cancel(boolean mayInterruptIfRunning) { 504 delegate.cancel(mayInterruptIfRunning); 505 } 506 507 @Override 508 public boolean isCancelled() { 509 return delegate.isCancelled(); 510 } 511 } 512 513 /** 514 * A {@link Scheduler} that provides a convenient way for the {@link AbstractScheduledService} to 515 * use a dynamically changing schedule. After every execution of the task, assuming it hasn't been 516 * cancelled, the {@link #getNextSchedule} method will be called. 517 * 518 * @author Luke Sandberg 519 * @since 11.0 520 */ 521 public abstract static class CustomScheduler extends Scheduler { 522 523 /** A callable class that can reschedule itself using a {@link CustomScheduler}. */ 524 private final class ReschedulableCallable implements Callable<@Nullable Void> { 525 526 /** The underlying task. */ 527 private final Runnable wrappedRunnable; 528 529 /** The executor on which this Callable will be scheduled. */ 530 private final ScheduledExecutorService executor; 531 532 /** 533 * The service that is managing this callable. This is used so that failure can be reported 534 * properly. 535 */ 536 /* 537 * This reference is part of a reference cycle, which is typically something we want to avoid 538 * under j2objc -- but it is not detected by our j2objc cycle test. The cycle: 539 * 540 * - CustomScheduler.service contains an instance of ServiceDelegate. (It needs it so that it 541 * can call notifyFailed.) 542 * 543 * - ServiceDelegate.runningTask contains an instance of ReschedulableCallable (at least in 544 * the case that the service is using CustomScheduler). (It needs it so that it can cancel 545 * the task and detect whether it has been cancelled.) 546 * 547 * - ReschedulableCallable has a reference back to its enclosing CustomScheduler. (It needs it 548 * so that it can call getNextSchedule). 549 * 550 * Maybe there is a way to avoid this cycle. But we think the cycle is safe enough to ignore: 551 * Each task is retained for only as long as it is running -- so it's retained only as long as 552 * it would already be retained by the underlying executor. 553 * 554 * If the cycle test starts reporting this cycle in the future, we should add an entry to 555 * cycle_suppress_list.txt. 556 */ 557 private final AbstractService service; 558 559 /** 560 * This lock is used to ensure safe and correct cancellation, it ensures that a new task is 561 * not scheduled while a cancel is ongoing. Also it protects the currentFuture variable to 562 * ensure that it is assigned atomically with being scheduled. 563 */ 564 private final ReentrantLock lock = new ReentrantLock(); 565 566 /** The future that represents the next execution of this task. */ 567 @GuardedBy("lock") 568 @CheckForNull 569 private SupplantableFuture cancellationDelegate; 570 571 ReschedulableCallable( 572 AbstractService service, ScheduledExecutorService executor, Runnable runnable) { 573 this.wrappedRunnable = runnable; 574 this.executor = executor; 575 this.service = service; 576 } 577 578 @Override 579 @CheckForNull 580 public Void call() throws Exception { 581 wrappedRunnable.run(); 582 reschedule(); 583 return null; 584 } 585 586 /** 587 * Atomically reschedules this task and assigns the new future to {@link 588 * #cancellationDelegate}. 589 */ 590 @CanIgnoreReturnValue 591 public Cancellable reschedule() { 592 // invoke the callback outside the lock, prevents some shenanigans. 593 Schedule schedule; 594 try { 595 schedule = CustomScheduler.this.getNextSchedule(); 596 } catch (Throwable t) { 597 restoreInterruptIfIsInterruptedException(t); 598 service.notifyFailed(t); 599 return new FutureAsCancellable(immediateCancelledFuture()); 600 } 601 // We reschedule ourselves with a lock held for two reasons. 1. we want to make sure that 602 // cancel calls cancel on the correct future. 2. we want to make sure that the assignment 603 // to currentFuture doesn't race with itself so that currentFuture is assigned in the 604 // correct order. 605 Throwable scheduleFailure = null; 606 Cancellable toReturn; 607 lock.lock(); 608 try { 609 toReturn = initializeOrUpdateCancellationDelegate(schedule); 610 } catch (Throwable e) { 611 // Any Exception is either a RuntimeException or sneaky checked exception. 612 // 613 // If an exception is thrown by the subclass then we need to make sure that the service 614 // notices and transitions to the FAILED state. We do it by calling notifyFailed directly 615 // because the service does not monitor the state of the future so if the exception is not 616 // caught and forwarded to the service the task would stop executing but the service would 617 // have no idea. 618 // TODO(lukes): consider building everything in terms of ListenableScheduledFuture then 619 // the AbstractService could monitor the future directly. Rescheduling is still hard... 620 // but it would help with some of these lock ordering issues. 621 scheduleFailure = e; 622 toReturn = new FutureAsCancellable(immediateCancelledFuture()); 623 } finally { 624 lock.unlock(); 625 } 626 // Call notifyFailed outside the lock to avoid lock ordering issues. 627 if (scheduleFailure != null) { 628 service.notifyFailed(scheduleFailure); 629 } 630 return toReturn; 631 } 632 633 @GuardedBy("lock") 634 /* 635 * The GuardedBy checker warns us that we're not holding cancellationDelegate.lock. But in 636 * fact we are holding it because it is the same as this.lock, which we know we are holding, 637 * thanks to @GuardedBy above. (cancellationDelegate.lock is initialized to this.lock in the 638 * call to `new SupplantableFuture` below.) 639 */ 640 @SuppressWarnings("GuardedBy") 641 private Cancellable initializeOrUpdateCancellationDelegate(Schedule schedule) { 642 if (cancellationDelegate == null) { 643 return cancellationDelegate = new SupplantableFuture(lock, submitToExecutor(schedule)); 644 } 645 if (!cancellationDelegate.currentFuture.isCancelled()) { 646 cancellationDelegate.currentFuture = submitToExecutor(schedule); 647 } 648 return cancellationDelegate; 649 } 650 651 private ScheduledFuture<@Nullable Void> submitToExecutor(Schedule schedule) { 652 return executor.schedule(this, schedule.delay, schedule.unit); 653 } 654 } 655 656 /** 657 * Contains the most recently submitted {@code Future}, which may be cancelled or updated, 658 * always under a lock. 659 */ 660 private static final class SupplantableFuture implements Cancellable { 661 private final ReentrantLock lock; 662 663 @GuardedBy("lock") 664 private Future<@Nullable Void> currentFuture; 665 666 SupplantableFuture(ReentrantLock lock, Future<@Nullable Void> currentFuture) { 667 this.lock = lock; 668 this.currentFuture = currentFuture; 669 } 670 671 @Override 672 public void cancel(boolean mayInterruptIfRunning) { 673 /* 674 * Lock to ensure that a task cannot be rescheduled while a cancel is ongoing. 675 * 676 * In theory, cancel() could execute arbitrary listeners -- bad to do while holding a lock. 677 * However, we don't expose currentFuture to users, so they can't attach listeners. And the 678 * Future might not even be a ListenableFuture, just a plain Future. That said, similar 679 * problems can exist with methods like FutureTask.done(), not to mention slow calls to 680 * Thread.interrupt() (as discussed in InterruptibleTask). At the end of the day, it's 681 * unlikely that cancel() will be slow, so we can probably get away with calling it while 682 * holding a lock. Still, it would be nice to avoid somehow. 683 */ 684 lock.lock(); 685 try { 686 currentFuture.cancel(mayInterruptIfRunning); 687 } finally { 688 lock.unlock(); 689 } 690 } 691 692 @Override 693 public boolean isCancelled() { 694 lock.lock(); 695 try { 696 return currentFuture.isCancelled(); 697 } finally { 698 lock.unlock(); 699 } 700 } 701 } 702 703 @Override 704 final Cancellable schedule( 705 AbstractService service, ScheduledExecutorService executor, Runnable runnable) { 706 return new ReschedulableCallable(service, executor, runnable).reschedule(); 707 } 708 709 /** 710 * A value object that represents an absolute delay until a task should be invoked. 711 * 712 * @author Luke Sandberg 713 * @since 11.0 714 */ 715 protected static final class Schedule { 716 717 private final long delay; 718 private final TimeUnit unit; 719 720 /** 721 * @param delay the time from now to delay execution 722 * @param unit the time unit of the delay parameter 723 */ 724 public Schedule(long delay, TimeUnit unit) { 725 this.delay = delay; 726 this.unit = checkNotNull(unit); 727 } 728 729 /** 730 * @param delay the time from now to delay execution 731 * @since 31.1 732 */ 733 public Schedule(Duration delay) { 734 this(toNanosSaturated(delay), NANOSECONDS); 735 } 736 } 737 738 /** 739 * Calculates the time at which to next invoke the task. 740 * 741 * <p>This is guaranteed to be called immediately after the task has completed an iteration and 742 * on the same thread as the previous execution of {@link 743 * AbstractScheduledService#runOneIteration}. 744 * 745 * @return a schedule that defines the delay before the next execution. 746 */ 747 // TODO(cpovirk): @ForOverride 748 protected abstract Schedule getNextSchedule() throws Exception; 749 } 750}