Java Code Examples for java.util.concurrent.ScheduledThreadPoolExecutor#scheduleAtFixedRate()

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));
    }
}
 

@Test
public void wrapException() {
	ScheduledThreadPoolExecutor executor = ThreadPoolBuilder.scheduledPool().build();
	ExceptionTask task = new ExceptionTask();
	executor.scheduleAtFixedRate(task, 0, 100, TimeUnit.MILLISECONDS);

	ThreadUtil.sleep(500);

	// 线程第一次跑就被中断
	assertThat(task.counter.get()).isEqualTo(1);
	ThreadPoolUtil.gracefulShutdown(executor, 1000);

	////////
	executor = ThreadPoolBuilder.scheduledPool().build();
	ExceptionTask newTask = new ExceptionTask();
	Runnable wrapTask = ThreadPoolUtil.safeRunnable(newTask);
	executor.scheduleAtFixedRate(wrapTask, 0, 100, TimeUnit.MILLISECONDS);

	ThreadUtil.sleep(500);
	assertThat(newTask.counter.get()).isGreaterThan(2);
	System.out.println("-------actual run:" + task.counter.get());
	ThreadPoolUtil.gracefulShutdown(executor, 1000);

}
 

private LifecycleListener scheduleReloadAtRate(final ConfigurationRegistry configurationRegistry, final int rate, TimeUnit seconds) {
    final ScheduledThreadPoolExecutor configurationReloader = ExecutorUtils.createSingleThreadSchedulingDeamonPool("configuration-reloader");
    configurationReloader.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            logger.debug("Beginning scheduled configuration reload (interval is {} sec)...", rate);
            configurationRegistry.reloadDynamicConfigurationOptions();
            logger.debug("Finished scheduled configuration reload");
        }
    }, rate, rate, seconds);
    return ClosableLifecycleListenerAdapter.of(new Closeable() {
        @Override
        public void close() {
            configurationReloader.shutdown();
        }
    });
}
 

public LockManager(RxSession session) {
    this.session = session;
    acquireLock = session.getSession().prepare(
            "UPDATE locks USING TTL ? SET value = ? WHERE name = ? IF value IN (NULL, ?)");
    releaseLock = session.getSession().prepare(
            "UPDATE locks SET value = NULL WHERE name = ? IF value = ?");
    renewLock = session.getSession().prepare(
            "UPDATE locks USING TTL ? SET value = ? WHERE name = ? IF value = ?");
    getTTL = session.getSession().prepare("SELECT TTL(value) FROM locks WHERE name = ?");

    ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("locks-thread-pool-%d").build();
    locksExecutor = new ScheduledThreadPoolExecutor(1, threadFactory, new ThreadPoolExecutor.DiscardPolicy());

    activeLocks = new HashMap<>();
    activeLocksLock = new ReentrantReadWriteLock();

    locksExecutor.scheduleAtFixedRate(this::renewLocks, 0, LOCK_RENEWAL_RATE, TimeUnit.SECONDS);
}
 

@Test
public void wrapException() {
	ScheduledThreadPoolExecutor executor = ThreadPoolBuilder.scheduledPool().build();
	ExceptionTask task = new ExceptionTask();
	executor.scheduleAtFixedRate(task, 0, 100, TimeUnit.MILLISECONDS);

	ThreadUtil.sleep(500);

	// 线程第一次跑就被中断
	assertThat(task.counter.get()).isEqualTo(1);
	ThreadPoolUtil.gracefulShutdown(executor, 1000);

	////////
	executor = ThreadPoolBuilder.scheduledPool().build();
	ExceptionTask newTask = new ExceptionTask();
	Runnable wrapTask = ThreadPoolUtil.safeRunnable(newTask);
	executor.scheduleAtFixedRate(wrapTask, 0, 100, TimeUnit.MILLISECONDS);

	ThreadUtil.sleep(500);
	assertThat(newTask.counter.get()).isGreaterThan(2);
	System.out.println("-------actual run:" + task.counter.get());
	ThreadPoolUtil.gracefulShutdown(executor, 1000);

}
 

/**
 * 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);
    }
}
 

@Override
public void activateService()
    throws Exception
{
    root = getApplicationRoot();

    // Reload underlying store every 60 seconds
    reloadExecutor = new ScheduledThreadPoolExecutor( 1 );
    reloadExecutor.setExecuteExistingDelayedTasksAfterShutdownPolicy( false );
    reloadExecutor.scheduleAtFixedRate( () -> {
        try
        {
            //noinspection SynchronizeOnNonFinalField
            synchronized( root )
            {
                root.sync();
            }
        }
        catch( BackingStoreException e )
        {
            throw new EntityStoreException( "Could not reload preferences", e );
        }
    }, 0, 60, TimeUnit.SECONDS );
}
 

public void init() {
  updateCacheStore();

  scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
  scheduledThreadPoolExecutor.setRemoveOnCancelPolicy(true);

  // check every 600 seconds (10 minutes)
  this.responseCleaner = scheduledThreadPoolExecutor.scheduleAtFixedRate(
      new ExpiredResponsesCleaner(), 348, 600, TimeUnit.SECONDS);

  // check every 600 seconds (10 minutes)
  this.issuerUpdater = scheduledThreadPoolExecutor.scheduleAtFixedRate(
      new IssuerUpdater(), 448, 600, TimeUnit.SECONDS);
}
 

/**
 * 设置固定时间执行
 */
private static void newScheduledThreadPool2() {
	 ScheduledThreadPoolExecutor  exec = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(10);   //创建大小为10的线程池  
	 long oneDay = 24 * 60 * 60 * 1000;    
	 long initDelay  = getTimeMillis("14:08:00") - System.currentTimeMillis();    
	 initDelay = initDelay > 0 ? initDelay : oneDay + initDelay;  
	 exec.scheduleAtFixedRate(new MyThread2(String.valueOf(1)), initDelay, oneDay, TimeUnit.MILLISECONDS);
     System.out.println("运行结束！");
}
 

/**
 * 设置固定时间执行
 */
private static void newScheduledThreadPool2() {
	 ScheduledThreadPoolExecutor  exec = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(10);   //创建大小为10的线程池  
	 long oneDay = 24 * 60 * 60 * 1000;    
	 long initDelay  = getTimeMillis("14:08:00") - System.currentTimeMillis();    
	 initDelay = initDelay > 0 ? initDelay : oneDay + initDelay;  
	 exec.scheduleAtFixedRate(new MyThread(String.valueOf(1)), initDelay, oneDay, TimeUnit.MILLISECONDS);
     System.out.println("运行结束！");
}
 

@Override
public void startHeartBeatThread() {
    scheduledpool = new ScheduledThreadPoolExecutor(1, new NamingThreadFactory(Thread.currentThread().getName().concat(LOCK_HEART_BEAT), true));
    scheduledpool.scheduleAtFixedRate(() -> {
        redisTemplate.expire(lockKey, ttl, TimeUnit.MILLISECONDS);
        logger.debug(MSG_RELET, Thread.currentThread().getName(), lockKey);
    }, 0L, ttl / 3, TimeUnit.MILLISECONDS);
    
}
 

@Override
public void start() {
    updateTimer = new ScheduledThreadPoolExecutor(1, new ThreadFactory() {
        @Override
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            thread.setName("StableRateLimiter-bucket-updater");
            return thread;
        }
    });
    updateTimer.scheduleAtFixedRate(this, 0, period, unit);
    stopped.set(false);
}
 

@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);
}
 

public Maintainer(String name, Duration interval, Duration initialDelay, JobControl jobControl) {
    this.name = name;
    this.interval = requireInterval(interval);
    this.jobControl = Objects.requireNonNull(jobControl);
    service = new ScheduledThreadPoolExecutor(1, r -> new Thread(r, name() + "-worker"));
    service.scheduleAtFixedRate(this, initialDelay.toMillis(), interval.toMillis(), TimeUnit.MILLISECONDS);
    jobControl.started(name(), this);
}
 

WeatherForecastPublisher() {
	super(Executors.newFixedThreadPool(2), Flow.defaultBufferSize());
	scheduler = new ScheduledThreadPoolExecutor(1);
	periodicTask = scheduler.scheduleAtFixedRate( //
			// runs submit()
			() -> submit(WeatherForecast.nextRandomWeatherForecast()), //
			500, 500, TimeUnit.MILLISECONDS);
}
 

private void startScheduler(int initialSize) {
  ScheduledThreadPoolExecutor scheduledExecutor = new ScheduledThreadPoolExecutor(initialSize, new DaemonThreadFactory("remote"));
  scheduledExecutor.scheduleAtFixedRate(this, 2000, 2000, TimeUnit.MILLISECONDS);
  scheduler = scheduledExecutor;
}
 

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);
    }
 

/**
 * Constructor
 *
 * @param eventManager EventManager
 * @param taskExecutor ScheduledThreadPoolExecutor
 */
public TwitchPubSub(EventManager eventManager, ScheduledThreadPoolExecutor taskExecutor) {
    this.taskExecutor = taskExecutor;
    this.eventManager = eventManager;
    // register with serviceMediator
    this.eventManager.getServiceMediator().addService("twitch4j-pubsub", this);

    // connect
    this.connect();

    // Run heartbeat every 4 minutes
    heartbeatTask = taskExecutor.scheduleAtFixedRate(() -> {
        if (isClosed)
            return;

        PubSubRequest request = new PubSubRequest();
        request.setType(PubSubType.PING);
        sendCommand(TypeConvert.objectToJson(request));

        log.debug("PubSub: Sending PING!");
        lastPing = TimeUtils.getCurrentTimeInMillis();
    }, 0, 4L, TimeUnit.MINUTES);

    // queue command worker
    this.queueTask = taskExecutor.schedule(() -> {
        while (!isClosed) {
            try {
                // check for missing pong response
                if (TimeUtils.getCurrentTimeInMillis() >= lastPing + 10000 && lastPong < lastPing) {
                    log.warn("PubSub: Didn't receive a PONG response in time, reconnecting to obtain a connection to a different server.");
                    reconnect();
                }

                // If connected, send one message from the queue
                String command = commandQueue.poll(1000L, TimeUnit.MILLISECONDS);
                if (command != null) {
                    if (connectionState.equals(TMIConnectionState.CONNECTED)) {
                        sendCommand(command);
                        // Logging
                        log.debug("Processed command from queue: [{}].", command);
                    }
                }
            } catch (Exception ex) {
                log.error("PubSub: Unexpected error in worker thread", ex);
            }
        }
    }, 1L, TimeUnit.MILLISECONDS);

    log.debug("PubSub: Started Queue Worker Thread");
}
 

public void start(Runnable onStartup, Runnable onTermination) {
	if (system.cells.size()==0)
		return;
	
	int poolSize = Runtime.getRuntime().availableProcessors();
	
	globalTimerExecuterService = new ActorTimerExecuterService(system, 1, "actor4j-global-timer-thread");
	timerExecuterService = new ActorTimerExecuterService(system, poolSize);
	
	resourceExecuterService = new ThreadPoolExecutor(poolSize, maxResourceThreads, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>(), new DefaultThreadFactory("actor4j-resource-thread"));
	if (system.clientMode)
		clientExecuterService = Executors.newSingleThreadExecutor();
	
	if (system.persistenceMode) {
		persistenceService = new ActorPersistenceService(system.wrapper, system.parallelismMin, system.parallelismFactor, system.persistenceConnector);
		persistenceService.start();
	}
	
	this.onTermination = onTermination;
	
	actorThreadPool = new ActorThreadPool(system);
	
	podReplicationControllerExecuterService = new ScheduledThreadPoolExecutor(1, new DefaultThreadFactory("actor4j-replication-controller-thread"));
	try {
		Constructor<? extends PodReplicationControllerRunnable> constructor;
		constructor = system.podReplicationControllerRunnableClass.getConstructor(ActorSystemImpl.class);
		podReplicationControllerRunnable = constructor.newInstance(system);
	} catch (Exception e) {
		e.printStackTrace();
	}
	if (podReplicationControllerRunnable!=null)
		podReplicationControllerExecuterService.scheduleAtFixedRate(podReplicationControllerRunnable, system.horizontalPodAutoscalerSyncTime, system.horizontalPodAutoscalerSyncTime, TimeUnit.MILLISECONDS);
	
	/*
	 * necessary before executing onStartup; 
	 * creating of childrens in Actor::preStart: childrens needs to register at the dispatcher
	 * (see also ActorSystemImpl::internal_addCell)
	 */
	started.set(true);
	
	if (onStartup!=null)
		onStartup.run();
}
 

public static void start() {
    ScheduledThreadPoolExecutor executor = TaskManager.createScheduledThreadPool(1, new NulsThreadFactory((short) 1, "version-manager"));
    executor.scheduleAtFixedRate(SyncVersionRunner.getInstance(), 0, 10, TimeUnit.MINUTES);
}