Java ScheduledThreadPoolExecutor.scheduleAtFixedRate方法代码示例

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
/**
 * Start the configured component loader
 *
 * @throws AgentException
 *             on error 
 */
private void startComponentLoader() throws AgentException {

    ComponentRepository componentRepository = ComponentRepository.getInstance();
    ConfigurationSettings settings = ConfigurationSettings.getInstance();

    log.info("Loading Agent component libraries from '" + settings.getComponentsFolder() + "'");

    // the default loader is the dynamic loader for hot deployment
    DynamicComponentLoader componentLoader = new DynamicComponentLoader(new File(settings.getComponentsFolder()),
                                                                        loadingMutex);

    log.info("Starting hot deployment thread");

    componentMonitor = new ScheduledThreadPoolExecutor(1);
    scheduledFuture = componentMonitor.scheduleAtFixedRate(new ComponentHotDeployTask(componentLoader,
                                                                                      componentRepository),
                                                           settings.getMonitorInitialDelay(),
                                                           settings.getMonitorPollInterval(),
                                                           TimeUnit.SECONDS);
}
 

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
@PostConstruct
    public void init() {

        scheduledExecutorService = new ScheduledThreadPoolExecutor(1,
                new BasicThreadFactory.Builder().namingPattern("SendNodeServerInfo-schedule-pool-%d").daemon(true).build());
        scheduledExecutorService.scheduleAtFixedRate(() ->
                {
                    //将负载加载到ZK中
                    if (!CollectionUtils.isEmpty(dataCenterChannelStore.getAllChannels())) {
                        dataCenterChannelStore.getAllChannels().stream().forEach(e -> {
                            log.info("channel id:{}, {}", e.id(), e);
                        });
                    }
                    applicationEventPublisher.publishEvent(
                            NodeServerInfoEvent.builder()
                                    .name(goPushNodeServerConfig.getName())
                                    .nodeServerInfo(watch())
                                    .build());
//                写入zk 其实不需要发送 NodeInfoReq
                    nodeSender.send(NodeInfoReq.builder().build());
                }
                , delay, delay, TimeUnit.MILLISECONDS);

    }
 

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
public void afterPropertiesSet() throws Exception {
    scheduler = new ScheduledThreadPoolExecutor(1, new NamedThreadFactory("Otter-Statistics-Table"),
                                                new ThreadPoolExecutor.CallerRunsPolicy());
    if (statUnit > 0) {
        scheduler.scheduleAtFixedRate(new Runnable() {

            public void run() {
                try {
                    flushBehaviorHistory();
                } catch (Exception e) {
                    logger.error("flush delay stat failed!", e);
                }
            }
        }, statUnit, statUnit, TimeUnit.MILLISECONDS);
    }
}
 

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
@Override
protected void serviceStart() throws Exception {
  hsManager.start();
  if (storage instanceof Service) {
    ((Service) storage).start();
  }

  scheduledExecutor = new ScheduledThreadPoolExecutor(2,
      new ThreadFactoryBuilder().setNameFormat("Log Scanner/Cleaner #%d")
          .build());

  scheduledExecutor.scheduleAtFixedRate(new MoveIntermediateToDoneRunnable(),
      moveThreadInterval, moveThreadInterval, TimeUnit.MILLISECONDS);

  // Start historyCleaner
  scheduleHistoryCleaner();
  super.serviceStart();
}
 

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
/**
 * scheduleAtFixedRate executes series of tasks at given rate.
 * Eventually, it must hold that:
 *   cycles - 1 <= elapsedMillis/delay < cycles
 */
public void testFixedRateSequence() throws InterruptedException {
    final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
    try (PoolCleaner cleaner = cleaner(p)) {
        for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
            final long startTime = System.nanoTime();
            final int cycles = 8;
            final CountDownLatch done = new CountDownLatch(cycles);
            final Runnable task = new CheckedRunnable() {
                public void realRun() { done.countDown(); }};
            final ScheduledFuture periodicTask =
                p.scheduleAtFixedRate(task, 0, delay, MILLISECONDS);
            final int totalDelayMillis = (cycles - 1) * delay;
            await(done, totalDelayMillis + LONG_DELAY_MS);
            periodicTask.cancel(true);
            final long elapsedMillis = millisElapsedSince(startTime);
            assertTrue(elapsedMillis >= totalDelayMillis);
            if (elapsedMillis <= cycles * delay)
                return;
            // else retry with longer delay
        }
        fail("unexpected execution rate");
    }
}
 

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
void scheduleNow(ScheduledThreadPoolExecutor pool,
                 Runnable r, int how) {
    switch (how) {
    case 0:
        pool.schedule(r, 0, MILLISECONDS);
        break;
    case 1:
        pool.schedule(Executors.callable(r), 0, DAYS);
        break;
    case 2:
        pool.scheduleWithFixedDelay(r, 0, 1000, NANOSECONDS);
        break;
    case 3:
        pool.scheduleAtFixedRate(r, 0, 1000, MILLISECONDS);
        break;
    default:
        fail(String.valueOf(how));
    }
}
 

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
void scheduleAtTheEndOfTime(ScheduledThreadPoolExecutor pool,
                            Runnable r, int how) {
    switch (how) {
    case 0:
        pool.schedule(r, Long.MAX_VALUE, MILLISECONDS);
        break;
    case 1:
        pool.schedule(Executors.callable(r), Long.MAX_VALUE, DAYS);
        break;
    case 2:
        pool.scheduleWithFixedDelay(r, Long.MAX_VALUE, 1000, NANOSECONDS);
        break;
    case 3:
        pool.scheduleAtFixedRate(r, Long.MAX_VALUE, 1000, MILLISECONDS);
        break;
    default:
        fail(String.valueOf(how));
    }
}
 

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
public static void main(String[] args)
{
    ScheduledThreadPoolExecutor scheduler = new ScheduledThreadPoolExecutor(
            10);
    Runnable event = new Runnable()
    {

        @Override
        public void run()
        {
            System.out.println("吃饭，睡觉，打豆豆");

        }
    };
    scheduler.schedule(event, 1, TimeUnit.SECONDS);
    scheduler.scheduleAtFixedRate(event, 5, 1, TimeUnit.SECONDS);
}
 

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
@PostConstruct
public void init() {
    scheduledExecutorService = new ScheduledThreadPoolExecutor(1,
            new BasicThreadFactory.Builder().namingPattern("SendDataCenterInfo-schedule-pool-%d").daemon(true).build());
    scheduledExecutorService.scheduleAtFixedRate(() -> applicationEventPublisher.publishEvent(DataCenterInfoEvent.builder()
            .name(goPushDataCenterConfig.getName())
            .dataCenterInfo(watch())
            .build()), delay, delay, TimeUnit.MILLISECONDS);
}
 

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
/**
 * scheduleAtFixedRate executes runnable after given initial delay
 */
public void testSchedule4() throws Exception {
    final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
    try (PoolCleaner cleaner = cleaner(p)) {
        final long startTime = System.nanoTime();
        final CountDownLatch done = new CountDownLatch(1);
        Runnable task = new CheckedRunnable() {
            public void realRun() {
                done.countDown();
                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
            }};
        ScheduledFuture f =
            p.scheduleAtFixedRate(task, timeoutMillis(),
                                  LONG_DELAY_MS, MILLISECONDS);
        await(done);
        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
        f.cancel(true);
    }
}
 

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
static void realMain(String[] args) throws Throwable {
    final int size = 10;
    final ScheduledThreadPoolExecutor pool
        = new ScheduledThreadPoolExecutor(size);
    final Runnable nop = new Runnable() { public void run() {}};

    for (int i = 0; i < size; i++)
        pool.scheduleAtFixedRate(nop, 100L * (i + 1),
                                 1000L, TimeUnit.MILLISECONDS);
    awaitPoolSize(pool, size);
    setCorePoolSize(pool, size - 3);
    setCorePoolSize(pool, size + 3);
    pool.shutdownNow();
    check(pool.awaitTermination(1L, TimeUnit.DAYS));
}
 

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
public void startProducer(){
    producerExecutorService = new ScheduledThreadPoolExecutor(1);
    producerExecutorService.scheduleAtFixedRate(obdCommandsProducer, 0, 1, TimeUnit.SECONDS);
}
 

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private void initMetrics() throws Exception {
  metrics = new MetricRegistry();
  // configuration
  metricsOutputDir = conf.get(SLSConfiguration.METRICS_OUTPUT_DIR);
  int metricsWebAddressPort = conf.getInt(
          SLSConfiguration.METRICS_WEB_ADDRESS_PORT,
          SLSConfiguration.METRICS_WEB_ADDRESS_PORT_DEFAULT);
  // create SchedulerMetrics for current scheduler
  String schedulerMetricsType = conf.get(scheduler.getClass().getName());
  Class schedulerMetricsClass = schedulerMetricsType == null?
          defaultSchedulerMetricsMap.get(scheduler.getClass()) :
          Class.forName(schedulerMetricsType);
  schedulerMetrics = (SchedulerMetrics)ReflectionUtils
          .newInstance(schedulerMetricsClass, new Configuration());
  schedulerMetrics.init(scheduler, metrics);

  // register various metrics
  registerJvmMetrics();
  registerClusterResourceMetrics();
  registerContainerAppNumMetrics();
  registerSchedulerMetrics();

  // .csv output
  initMetricsCSVOutput();

  // start web app to provide real-time tracking
  web = new SLSWebApp(this, metricsWebAddressPort);
  web.start();

  // a thread to update histogram timer
  pool = new ScheduledThreadPoolExecutor(2);
  pool.scheduleAtFixedRate(new HistogramsRunnable(), 0, 1000,
          TimeUnit.MILLISECONDS);

  // a thread to output metrics for real-tiem tracking
  pool.scheduleAtFixedRate(new MetricsLogRunnable(), 0, 1000,
          TimeUnit.MILLISECONDS);

  // application running information
  jobRuntimeLogBW = new BufferedWriter(
          new FileWriter(metricsOutputDir + "/jobruntime.csv"));
  jobRuntimeLogBW.write("JobID,real_start_time,real_end_time," +
          "simulate_start_time,simulate_end_time" + EOL);
  jobRuntimeLogBW.flush();
}
 

import java.util.concurrent.ScheduledThreadPoolExecutor; //导入方法依赖的package包/类
public static void main(String[] args) throws Throwable {

        final CountDownLatch count = new CountDownLatch(1000);

        final ScheduledThreadPoolExecutor pool =
            new ScheduledThreadPoolExecutor(100);
        pool.prestartAllCoreThreads();

        final Runnable incTask = new Runnable() { public void run() {
            count.countDown();
        }};

        pool.scheduleAtFixedRate(incTask, 0, 10, TimeUnit.MILLISECONDS);

        count.await();

        pool.shutdown();
        pool.awaitTermination(1L, TimeUnit.DAYS);
    }