private void scheduleClockUpdating() { ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() { @Override public Thread newThread(Runnable runnable) { Thread thread = new Thread(runnable, "System Clock"); thread.setDaemon(true); return thread; } }); scheduler.scheduleAtFixedRate(new Runnable() { @Override public void run() { now.set(System.currentTimeMillis()); } }, period, period, TimeUnit.MILLISECONDS); }
public GraphService(boolean autoReload) { if (autoReload) { scanExecutor = Executors.newSingleThreadScheduledExecutor(); scanExecutor.scheduleWithFixedDelay(new Runnable() { @Override public void run() { autoReloadScan(); } }, AUTORELOAD_PERIOD_SEC, AUTORELOAD_PERIOD_SEC, TimeUnit.SECONDS); } }
protected void startReloadThread() { if (this.reloadIntervalSeconds > 0) { this.scheduler = Executors.newSingleThreadScheduledExecutor(); ((ScheduledExecutorService) this.scheduler).scheduleAtFixedRate(this, reloadIntervalSeconds, reloadIntervalSeconds, TimeUnit.SECONDS); } }
@PostConstruct public void initTimerCheck() { Executors.newSingleThreadScheduledExecutor().scheduleWithFixedDelay( () -> onApplicationEvent(null), CHECK_INTERVAL, CHECK_INTERVAL, TimeUnit.SECONDS); }
@WebListener public class BackgroundJobManager implements ServletContextListener { private ScheduledExecutorService scheduler; @Override public void contextInitialized(ServletContextEvent event) { scheduler = Executors.newSingleThreadScheduledExecutor(); scheduler.scheduleAtFixedRate(new YourParsingJob(), 0, 5, TimeUnit.HOUR); } @Override public void contextDestroyed(ServletContextEvent event) { scheduler.shutdownNow(); } }
void startTriggerValidator(long triggerValidationIntervalMs) { if (scheduledExecutorService == null) { scheduledExecutorService = Executors.newSingleThreadScheduledExecutor( new ThreadFactoryBuilder().setDaemon(true).setNameFormat("TriggerValidator").build()); Runnable triggerValidatorRunnable = getTriggerValidatorRunnable(); scheduledExecutorService.scheduleWithFixedDelay(triggerValidatorRunnable, triggerValidationIntervalMs, triggerValidationIntervalMs, TimeUnit.MILLISECONDS); LOG.info("Started trigger validator with interval: {} ms", triggerValidationIntervalMs); } }
private void initialize() { Executors.newSingleThreadScheduledExecutor(ApolloThreadFactory.create("SpringValueRegistry", true)).scheduleAtFixedRate( new Runnable() { @Override public void run() { try { scanAndClean(); } catch (Throwable ex) { ex.printStackTrace(); } } }, CLEAN_INTERVAL_IN_SECONDS, CLEAN_INTERVAL_IN_SECONDS, TimeUnit.SECONDS); }
@Inject public MySQLMetadataDAO(ObjectMapper om, DataSource dataSource, Configuration config) { super(om, dataSource); int cacheRefreshTime = config.getIntProperty(PROP_TASKDEF_CACHE_REFRESH, DEFAULT_TASKDEF_CACHE_REFRESH_SECONDS); Executors.newSingleThreadScheduledExecutor() .scheduleWithFixedDelay(this::refreshTaskDefs, cacheRefreshTime, cacheRefreshTime, TimeUnit.SECONDS); }
@WebListener public class BackgroundJobManager implements ServletContextListener { private ScheduledExecutorService scheduler; @Override public void contextInitialized(ServletContextEvent event) { scheduler = Executors.newSingleThreadScheduledExecutor(); scheduler.scheduleAtFixedRate(new SomeDailyJob(), 0, 1, TimeUnit.DAYS); scheduler.scheduleAtFixedRate(new SomeHourlyJob(), 0, 1, TimeUnit.HOURS); scheduler.scheduleAtFixedRate(new SomeQuarterlyJob(), 0, 15, TimeUnit.MINUTES); } @Override public void contextDestroyed(ServletContextEvent event) { scheduler.shutdownNow(); } }
public void start() { executor = Executors.newSingleThreadScheduledExecutor(new NamedThreadFactory("consumer-checker")); executor.scheduleWithFixedDelay(this, 5, 3, TimeUnit.MINUTES); }
/** * 开启计时器线程 */ private void scheduleClockUpdating() { ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(new ThreadFactory(){ @Override public Thread newThread(Runnable runnable) { Thread thread = new Thread(runnable, "System Clock"); thread.setDaemon(true); return thread; } }); scheduler.scheduleAtFixedRate(new Runnable(){ @Override public void run() { now = System.currentTimeMillis(); } }, period, period, TimeUnit.MILLISECONDS); }
@Override public void start() { LOGGER.info("Configuration provider starting"); Preconditions.checkState(file != null, "The parameter file must not be null"); executorService = Executors.newSingleThreadScheduledExecutor( new ThreadFactoryBuilder().setNameFormat("conf-file-poller-%d") .build()); FileWatcherRunnable fileWatcherRunnable = new FileWatcherRunnable(file, counterGroup); executorService.scheduleWithFixedDelay(fileWatcherRunnable, 0, interval, TimeUnit.SECONDS); lifecycleState = LifecycleState.START; LOGGER.debug("Configuration provider started"); }
private void scheduleClockUpdating() { ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(runnable -> { Thread thread = new Thread(runnable, "System Clock"); thread.setDaemon(true); return thread; }); scheduler.scheduleAtFixedRate(() -> now.set(System.currentTimeMillis()), period, period, TimeUnit.MILLISECONDS); }
@PostConstruct @SuppressWarnings("PMD.ThreadPoolCreationRule") public void init() { // 每个Server都有修正usage的Job在跑,幂等 ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat( "com.alibaba.nacos.CapacityManagement-%d").setDaemon(true).build(); scheduledExecutorService = Executors.newSingleThreadScheduledExecutor(threadFactory); scheduledExecutorService.scheduleWithFixedDelay(new Runnable() { @Override public void run() { LOGGER.info("[capacityManagement] start correct usage"); Stopwatch stopwatch = Stopwatch.createStarted(); correctUsage(); LOGGER.info("[capacityManagement] end correct usage, cost: {}s", stopwatch.elapsed(TimeUnit.SECONDS)); } }, PropertyUtil.getCorrectUsageDelay(), PropertyUtil.getCorrectUsageDelay(), TimeUnit.SECONDS); }
/** * 开启计时器线程 */ private void scheduleClockUpdating() { ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(new ThreadFactory(){ @Override public Thread newThread(Runnable runnable) { Thread thread = new Thread(runnable, "System Clock"); thread.setDaemon(true); return thread; } }); scheduler.scheduleAtFixedRate(new Runnable(){ @Override public void run() { now = System.currentTimeMillis(); } }, period, period, TimeUnit.MILLISECONDS); }
private void startIfNeeded() { if ( active ) { return; } statelock.writeLock().lock(); try { if ( active ) { return; } executorService = Executors.newSingleThreadScheduledExecutor( new ValidationThreadFactory() ); executorService.scheduleWithFixedDelay( pool::validate, validationInterval, validationInterval, TimeUnit.SECONDS ); active = true; } finally { statelock.writeLock().unlock(); } }
ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor(); exec.scheduleAtFixedRate(runnable, 0, 1000, TimeUnit.MILLISECONDS);
ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(); ScheduledFuture<?> handle = scheduler.scheduleWithFixedDelay(new Runnable() { public void run() { throw new RuntimeException("foo"); } }, 1, 10, TimeUnit.SECONDS); // Create and Start an exception handler thread // pass the "handle" object to the thread // Inside the handler thread do : .... try { handle.get(); } catch (ExecutionException e) { Exception rootException = e.getCause(); }
private ScheduledExecutorService scheduler; public void contextInitialized(ServletContextEvent event) { scheduler = Executors.newSingleThreadScheduledExecutor(); scheduler.scheduleAtFixedRate(new CleanDBTask(), 0, 1, TimeUnit.HOURS); scheduler.scheduleAtFixedRate(new StatisticsTask(), 0, 15, TimeUnit.MINUTES); } public void contextDestroyed(ServletContextEvent event) { scheduler.shutdownNow(); }
public MemIndex(final StoreConfig storeConfig, DataBlockEngine<K, V> dataBlockEngine, DataCache<K, V> dataCache) { this.indexMap = new ConcurrentSkipListMap<K, IndexItem<K>>(); this.storeConfig = storeConfig; this.dataBlockEngine = dataBlockEngine; this.dataCache = dataCache; ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor(new NamedThreadFactory("ltsdb-index-snapshot-check-service", true)); executorService.scheduleWithFixedDelay(new Runnable() { @Override public void run() { try { // 检查一下当改变的量达到一定量时要snapshot if (currentChangeNum.get() - lastSnapshotChangeNum.get() > storeConfig.getIndexSnapshotThreshold()) { indexSnapshot.snapshot(); } } catch (Throwable t) { LOGGER.error("SNAPSHOT Error", t); } } }, 3, 2, TimeUnit.SECONDS); }