Examples of java.util.concurrent.ScheduledExecutorService

java.util.concurrent.ScheduledExecutorService
An {@link ExecutorService} that can schedule commands to run after a givendelay, or to execute periodically.
The {@code schedule} methods create tasks with various delaysand return a task object that can be used to cancel or check execution. The {@code scheduleAtFixedRate} and{@code scheduleWithFixedDelay} methods create and execute tasksthat run periodically until cancelled.
Commands submitted using the {@link Executor#execute(Runnable)}and {@link ExecutorService} {@code submit} methods are scheduledwith a requested delay of zero. Zero and negative delays (but not periods) are also allowed in {@code schedule} methods, and aretreated as requests for immediate execution.
All {@code schedule} methods accept relative delays andperiods as arguments, not absolute times or dates. It is a simple matter to transform an absolute time represented as a {@link java.util.Date} to the required form. For example, to schedule ata certain future {@code date}, you can use: {@code schedule(task,date.getTime() - System.currentTimeMillis(), TimeUnit.MILLISECONDS)}. Beware however that expiration of a relative delay need not coincide with the current {@code Date} atwhich the task is enabled due to network time synchronization protocols, clock drift, or other factors.
The {@link Executors} class provides convenient factory methods forthe ScheduledExecutorService implementations provided in this package.
Usage Example
Here is a class with a method that sets up a ScheduledExecutorService to beep every ten seconds for an hour:
```
  {@code import static java.util.concurrent.TimeUnit.*;}class BeeperControl  private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1); public void beepForAnHour() { final Runnable beeper = new Runnable() { public void run() { System.out.println("beep"); } }; final ScheduledFuture beeperHandle = scheduler.scheduleAtFixedRate(beeper, 10, 10, SECONDS); scheduler.schedule(new Runnable() { public void run() { beeperHandle.cancel(true); } }, 60 * 60, SECONDS); } }}
```
@since 1.5 @author Doug Lea


   public void start()
   {
      // start a thread, garbage expired cookie token every [DELAY_TIME]
      final AbstractTokenService service = this;
      ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
      executor.scheduleWithFixedDelay(new Runnable()
      {
         public void run()
         {
            service.cleanExpiredTokens();
         }

View Full Code Here

    executor.setThreadFactory(new ThreadFactoryBuilder()
        .setDaemon(true)
        .setThreadFactory(executor.getThreadFactory())
        .build());


    ScheduledExecutorService service =
        Executors.unconfigurableScheduledExecutorService(executor);


    addDelayedShutdownHook(service, terminationTimeout, timeUnit);


    return service;

View Full Code Here

            if (!(transport.getOOBThreadPool() instanceof ManagedExecutorService)) {
                transport.setOOBThreadPool(new ManagedExecutorService(oobExecutor));
            }
        }
        
        ScheduledExecutorService timerExecutor = transportConfig.getTimerExecutor();
        if (timerExecutor != null) {
          
        }
  }

View Full Code Here

  {
    super.init();
    mountPage("feed", FeedPage.class);
    mountPage("add-content", AddContentPage.class);
    
    ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
    executor.scheduleAtFixedRate(new TimestamperTask(this), 0, 30, TimeUnit.SECONDS);
  }

View Full Code Here

    private static final int SCHEDULED_THREADS_POOL_SIZE = 30;


    @Override
    protected void configure() {
        // TODO Add instrumentation to ExecutorService and ThreadFactory
        final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(SCHEDULED_THREADS_POOL_SIZE,
                new ThreadFactoryBuilder()
                        .setNameFormat("scheduled-%d")
                        .setDaemon(false)
                        .setUncaughtExceptionHandler(new Tools.LogUncaughtExceptionHandler(LoggerFactory.getLogger("org.graylog2.scheduler.Scheduler")))
                        .build()
        );


        bind(ScheduledExecutorService.class).annotatedWith(Names.named("scheduler")).toInstance(scheduler);


        // TODO Add instrumentation to ExecutorService and ThreadFactory
        final ScheduledExecutorService daemonScheduler = Executors.newScheduledThreadPool(SCHEDULED_THREADS_POOL_SIZE,
                new ThreadFactoryBuilder()
                        .setNameFormat("scheduled-daemon-%d")
                        .setDaemon(true)
                        .setUncaughtExceptionHandler(new Tools.LogUncaughtExceptionHandler(LoggerFactory.getLogger("org.graylog2.scheduler.DaemonScheduler")))
                        .build()

View Full Code Here

                    "Starting [{}] periodical in [{}s], polling every [{}s].",
                    periodical.getClass().getCanonicalName(),
                    periodical.getInitialDelaySeconds(),
                    periodical.getPeriodSeconds());


            ScheduledExecutorService scheduler = periodical.isDaemon() ? this.daemonScheduler : this.scheduler;
            ScheduledFuture<?> future = scheduler.scheduleAtFixedRate(
                    periodical,
                    periodical.getInitialDelaySeconds(),
                    periodical.getPeriodSeconds(),
                    TimeUnit.SECONDS
            );

View Full Code Here

            LOG.warn("Setting counter from {} to 0 because the queue is empty!", counter.get());
            counter.set(0);
            commit();
        }


        final ScheduledExecutorService commitService = commitExecutorService();
        commitService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                try {
                    commit();
                } catch (Exception e) {

View Full Code Here

                return new HostPort(input);
            }
        }));


        // every so often, we bring back a black-listed server
        ScheduledExecutorService background = Executors.newSingleThreadScheduledExecutor();
        background.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                if (serverBlackList.size() > 0) {
                    serverBlackList.elementSet().remove(serverBlackList.iterator().next());
                }

View Full Code Here

            if (executorService instanceof ScheduledExecutorService) {
                return (ScheduledExecutorService) executorService;
            }
            throw new IllegalArgumentException("ExecutorServiceRef " + definition.getExecutorServiceRef() + " is not an ScheduledExecutorService instance");
        } else if (definition.getExecutorServiceRef() != null) {
            ScheduledExecutorService answer = lookupScheduledExecutorServiceRef(routeContext, name, definition, definition.getExecutorServiceRef());
            if (answer == null) {
                throw new IllegalArgumentException("ExecutorServiceRef " + definition.getExecutorServiceRef() + " not found in registry or as a thread pool profile.");
            }
            return answer;
        } else if (useDefault) {

View Full Code Here

    public void shouldSupportConcurrentlyCreatingNewKeys() throws InterruptedException {
        // note. this test did never actually trigger the race condition so only limited confidence here.
        // this is the best I've come up with so far for actually triggering the conditions this breaks
        int factor = 666;
        int startIndex = EfficientString.nextIndex();
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(20);
        final JsonObject o = new JsonObject();
        // this should create some potential for the race condition to trigger since it rapidly creates the same keys
        int total = 100000;
        for(int i=0;i<total;i++) {
            // make sure we are actually creating new Strings with no overlap with the other tests
            final String str="shouldSupportConcurrentlyCreatingNewKeys-"+ (i/factor);
            executorService.execute(new Runnable() {


                @Override
                public void run() {
                    o.put(str, str); // this should never fail with null key because of the (hopefully) now fixed EfficientString
                    EfficientString e = EfficientString.fromString(str);
                    assertThat(EfficientString.fromString(str), is(e));
                }
            });
        }


        executorService.shutdown();
        executorService.awaitTermination(2, TimeUnit.SECONDS);
        // check greater than so that it won't clash with concurrent executions of other tests in surefire
        assertThat(EfficientString.nextIndex()-startIndex, Matchers.greaterThan(total/factor));
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.util.concurrent.ScheduledExecutorService

com.alibaba.cobar.client.datasources.ha.FailoverHotSwapDataSourceCreator

com.alibaba.jstorm.batch.example.BatchMetaRebalance

com.alibaba.jstorm.daemon.nimbus.NimbusServer

com.comcast.cqs.test.stress.CqsStressTester

com.dietsodasoftware.yail.oauth2.Oauth2FlowDemo

com.google.common.util.concurrent.MoreExecutors

com.hazelcast.client.executor.ExecutionDelayTest

com.hazelcast.partition.impl.InternalPartitionServiceImpl

com.linkedin.d2.balancer.simple.SimpleLoadBalancerTest

com.linkedin.r2.transport.http.client.TestHttpClientFactory

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of java.util.concurrent.ScheduledExecutorService

Usage Example

Related Classes of java.util.concurrent.ScheduledExecutorService