下面列出了怎么用com.google.common.util.concurrent.ListenableScheduledFuture的API类实例代码及写法,或者点击链接到github查看源代码。
public synchronized void start(Runnable task) {
if (isStarted()) {
return;
}
requireNonNull(task, "task");
final ListeningScheduledExecutorService scheduler = MoreExecutors.listeningDecorator(purgeWorker);
this.scheduler = scheduler;
@SuppressWarnings("UnstableApiUsage")
final ListenableScheduledFuture<?> future = scheduler.scheduleWithFixedDelay(
task,
TICK.getSeconds(), TICK.getSeconds(), TimeUnit.SECONDS);
Futures.addCallback(future, new FutureCallback<Object>() {
@Override
public void onSuccess(@Nullable Object result) {}
@Override
public void onFailure(Throwable cause) {
logger.error("Storage purge scheduler stopped due to an unexpected exception:", cause);
}
}, purgeWorker);
}
@Override
public ListenableFuture<?> work() {
int publishingBatchNum = statusInfo.getFinishedBatchNum() + 1;
final List<Host> machines = statusInfo.getBatches().get(publishingBatchNum);
preparePush(machines);
ListenableFuture<?> f1 = executor.submit(new Runnable() {
@Override
public void run() {
push(machines);
}
});
ListenableScheduledFuture<?> f2 = executor.schedule(new Runnable() {
@Override
public void run() {
push(machines);
}
}, DELAY_TIME_MS, TimeUnit.MILLISECONDS);
ListenableFuture<List<Object>> workFuture = Futures.successfulAsList(f1, f2);
workFuture.addListener(new Runnable() {
@Override
public void run() {
accept(Command.next);
}
}, Constants.CURRENT_EXECUTOR);
return workFuture;
}
private void scheduleNextRefresh(boolean refreshWasSuccessful) {
int delayInMinutes =
refreshWasSuccessful ? SUCESSFUL_DOWNLOAD_DELAY_MINUTES : DOWNLOAD_FAILURE_DELAY_MINUTES;
ListenableScheduledFuture<String> refreshResults =
executor.schedule(new WebExperimentsDownloader(), delayInMinutes, TimeUnit.MINUTES);
refreshResults.addListener(
new WebExperimentsResultProcessor(refreshResults), MoreExecutors.directExecutor());
}
@NotNull
private ListenableScheduledFuture<?> scheduleSend(Services services, String olvVersion, Map<String, Long> stats, String uuid, String javaVersion) {
return services
.getTaskSchedulerService()
.getListeningScheduledExecutorService()
.schedule(() -> {
send(services, olvVersion, stats, uuid, javaVersion);
}, 2L, TimeUnit.SECONDS);
}
@Override
public void valueChanged(ListSelectionEvent e) {
boolean hasFocus = otrosApplication.getApplicationJFrame().isFocused();
final boolean enabled = otrosApplication.getConfiguration().getBoolean(ConfKeys.JUMP_TO_CODE_AUTO_JUMP_ENABLED, false);
if (hasFocus && enabled && !e.getValueIsAdjusting()) {
try {
final LogData logData = dataTableModel.getLogData(table.convertRowIndexToModel(e.getFirstIndex()));
Optional<Integer> line = Optional.empty();
if (StringUtils.isNotBlank(logData.getLine()) && StringUtils.isAlphanumeric(logData.getLine())) {
line = Optional.of(Integer.valueOf(logData.getLine()));
}
final LocationInfo li = new LocationInfo(
Optional.ofNullable(logData.getClazz()).orElseGet(logData::getLoggerName),
logData.getMethod(), logData.getFile(),
line,
Optional.ofNullable(logData.getMessage()));
final JumpToCodeService jumpToCodeService = otrosApplication.getServices().getJumpToCodeService();
final boolean ideAvailable = jumpToCodeService.isIdeAvailable();
if (ideAvailable) {
scheduledJump.map(input -> {
input.cancel(false);
return Boolean.TRUE;
});
ListeningScheduledExecutorService scheduledExecutorService = otrosApplication.getServices().getTaskSchedulerService().getListeningScheduledExecutorService();
delayMs = 300;
ListenableScheduledFuture<?> jump = scheduledExecutorService.schedule(
new JumpRunnable(li, jumpToCodeService), delayMs, TimeUnit.MILLISECONDS
);
scheduledJump = Optional.of(jump);
}
} catch (Exception e1) {
LOGGER.warn("Can't perform jump to code: " + e1.getMessage(), e1);
e1.printStackTrace();
}
}
}
@Test
public void testConfigWithDslNotReadyImmediately() throws Exception {
final ConfigKey<String> configKey = ConfigKeys.newStringConfigKey("testConfig");
BrooklynDslDeferredSupplier<?> dsl = BrooklynDslCommon.config(configKey.getName());
Function<Entity, ConfigValuePair> valueSupplier = new Function<Entity, ConfigValuePair>() {
private ListenableScheduledFuture<?> future;
@Override
public ConfigValuePair apply(final Entity entity) {
try {
// If executed in a loop, then wait for previous call's future to complete.
// If previous assertion used getImmediately, then it won't have waited for the future to complete.
if (future != null) {
future.get(Asserts.DEFAULT_LONG_TIMEOUT.toMilliseconds(), TimeUnit.MILLISECONDS);
future = null;
}
// Reset sensor - otherwise if run in a loop the old value will be picked up, before our execute sets the new value
entity.sensors().set(TestApplication.MY_ATTRIBUTE, null);
final String expectedValue = Identifiers.makeRandomId(10);
Runnable job = new Runnable() {
@Override
public void run() {
entity.sensors().set(TestApplication.MY_ATTRIBUTE, expectedValue);
}
};
future = executor.schedule(job, random.nextInt(20), TimeUnit.MILLISECONDS);
BrooklynDslDeferredSupplier<?> attributeDsl = BrooklynDslCommon.attributeWhenReady(TestApplication.MY_ATTRIBUTE.getName());
return new ConfigValuePair(attributeDsl, expectedValue);
} catch (Exception e) {
throw Exceptions.propagate(e);
}
}
};
new ConfigTestWorker(app, configKey, valueSupplier, dsl).satisfiedAsynchronously(true).resolverIterations(2).run();
}
public synchronized void start(CommandExecutor commandExecutor) {
if (isStarted()) {
return;
}
this.commandExecutor = requireNonNull(commandExecutor, "commandExecutor");
scheduler = MoreExecutors.listeningDecorator(Executors.newSingleThreadScheduledExecutor(
new DefaultThreadFactory("mirroring-scheduler", true)));
// Use SynchronousQueue to prevent the work queue from growing infinitely
// when the workers cannot handle the mirroring tasks fast enough.
final SynchronousQueue<Runnable> workQueue = new SynchronousQueue<>();
worker = MoreExecutors.listeningDecorator(new ThreadPoolExecutor(
0, numThreads, 90, TimeUnit.SECONDS, workQueue,
new DefaultThreadFactory("mirroring-worker", true),
(rejectedTask, executor) -> {
// We do not want the mirroring tasks to be rejected.
// Just wait until a worker thread takes it.
try {
workQueue.put(rejectedTask);
} catch (InterruptedException e) {
// Propagate the interrupt to the scheduler.
Thread.currentThread().interrupt();
}
}));
final ListenableScheduledFuture<?> future = scheduler.scheduleWithFixedDelay(
this::schedulePendingMirrors,
TICK.getSeconds(), TICK.getSeconds(), TimeUnit.SECONDS);
Futures.addCallback(future, new FutureCallback<Object>() {
@Override
public void onSuccess(@Nullable Object result) {}
@Override
public void onFailure(Throwable cause) {
logger.error("Git-to-CD mirroring scheduler stopped due to an unexpected exception:", cause);
}
}, MoreExecutors.directExecutor());
}
public static ListenableScheduledFuture<?> scheduleTask(long millis, Runnable r) {
return service.schedule(r, millis, TimeUnit.MILLISECONDS);
}
public static ListenableScheduledFuture<?> scheduleTask(long millis, long period, Runnable r) {
return service.scheduleAtFixedRate(r, millis, period, TimeUnit.MILLISECONDS);
}
@Override
public ListenableScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
ListenableFutureTask<Void> task = ListenableFutureTask.create(new MDCPropagatingRunnable(command), null);
ScheduledFuture<?> scheduled = executorService.schedule(task, delay, unit);
return new ListenableScheduledTask<>(task, scheduled);
}
@Override
public <V> ListenableScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
ListenableFutureTask<V> task = ListenableFutureTask.create(new MDCPropagatingCallable<>(callable));
ScheduledFuture<?> scheduled = executorService.schedule(task, delay, unit);
return new ListenableScheduledTask<>(task, scheduled);
}
@Override
public ListenableScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
NeverSuccessfulListenableFutureTask task = new NeverSuccessfulListenableFutureTask(new MDCPropagatingRunnable(command));
ScheduledFuture<?> scheduled = executorService.scheduleAtFixedRate(task, initialDelay, period, unit);
return new ListenableScheduledTask<>(task, scheduled);
}
@Override
public ListenableScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
NeverSuccessfulListenableFutureTask task = new NeverSuccessfulListenableFutureTask(new MDCPropagatingRunnable(command));
ScheduledFuture<?> scheduled = executorService.scheduleWithFixedDelay(task, initialDelay, delay, unit);
return new ListenableScheduledTask<>(task, scheduled);
}
@Override
public ListenableScheduledFuture<?> schedule(Runnable runnable, long l, TimeUnit timeUnit) {
return delegate.schedule(runnable, 0, timeUnit);
}
@Override
public <V> ListenableScheduledFuture<V> schedule(
Callable<V> callable, long l, TimeUnit timeUnit) {
return delegate.schedule(callable, 0, timeUnit);
}
@Override
public ListenableScheduledFuture<?> scheduleAtFixedRate(
Runnable runnable, long l, long l1, TimeUnit timeUnit) {
return delegate.scheduleAtFixedRate(runnable, 0, 0, timeUnit);
}
@Override
public ListenableScheduledFuture<?> scheduleWithFixedDelay(
Runnable runnable, long l, long l1, TimeUnit timeUnit) {
return delegate.scheduleWithFixedDelay(runnable, 0, 0, timeUnit);
}
private void runQps() throws InterruptedException, ExecutionException {
final SettableFuture<Void> failure = SettableFuture.create();
final class PeriodicRpc implements Runnable {
@Override
public void run() {
final long requestId;
final Set<XdsStatsWatcher> savedWatchers = new HashSet<>();
synchronized (lock) {
currentRequestId += 1;
requestId = currentRequestId;
savedWatchers.addAll(watchers);
}
SimpleRequest request = SimpleRequest.newBuilder().setFillServerId(true).build();
ManagedChannel channel = channels.get((int) (requestId % channels.size()));
final ClientCall<SimpleRequest, SimpleResponse> call =
channel.newCall(
TestServiceGrpc.getUnaryCallMethod(),
CallOptions.DEFAULT.withDeadlineAfter(rpcTimeoutSec, TimeUnit.SECONDS));
call.start(
new ClientCall.Listener<SimpleResponse>() {
private String hostname;
@Override
public void onMessage(SimpleResponse response) {
hostname = response.getHostname();
// TODO(ericgribkoff) Currently some test environments cannot access the stats RPC
// service and rely on parsing stdout.
if (printResponse) {
System.out.println(
"Greeting: Hello world, this is "
+ hostname
+ ", from "
+ call.getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR));
}
}
@Override
public void onClose(Status status, Metadata trailers) {
if (printResponse && !status.isOk()) {
logger.log(Level.WARNING, "Greeting RPC failed with status {0}", status);
}
for (XdsStatsWatcher watcher : savedWatchers) {
watcher.rpcCompleted(requestId, hostname);
}
}
},
new Metadata());
call.sendMessage(request);
call.request(1);
call.halfClose();
}
}
long nanosPerQuery = TimeUnit.SECONDS.toNanos(1) / qps;
ListenableScheduledFuture<?> future =
exec.scheduleAtFixedRate(new PeriodicRpc(), 0, nanosPerQuery, TimeUnit.NANOSECONDS);
Futures.addCallback(
future,
new FutureCallback<Object>() {
@Override
public void onFailure(Throwable t) {
failure.setException(t);
}
@Override
public void onSuccess(Object o) {}
},
MoreExecutors.directExecutor());
failure.get();
}