Java Executors.newScheduledThreadPool方法代码示例

import java.util.concurrent.Executors; //导入方法依赖的package包/类
/**
 *
 * @param zkMonitorListener a {@link ZKMonitorCallback} instance
 * @param zkNodeAddress Zookeeper server address
 * @param zkNodePollingDelay  Amount of time in ms to poll zookeeper node
 * @param zkNodePollingInitialDelay Amount of initial time in ms before starting poll
 */
public ZKNodeWatcher(final ZKMonitorCallback zkMonitorListener,
                     final InetSocketAddress zkNodeAddress,
                     final int zkNodePollingDelay,
                     final int zkNodePollingInitialDelay) {

    validateArguments(zkMonitorListener,
            zkNodeAddress,
            zkNodePollingDelay,
            zkNodePollingInitialDelay);

    this.zkNodeAddress = zkNodeAddress;
    this.zkMonitorListener = zkMonitorListener;
    this.zkNodePollingDelay = zkNodePollingDelay;
    this.zkNodePollingInitialDelay = zkNodePollingInitialDelay;
    this.executor = Executors.newScheduledThreadPool(1);

}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
private static void fixedDelay() {
  ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

  Runnable task = () -> {
    try {
      System.out.println("Scheduling: " + System.nanoTime());
      TimeUnit.SECONDS.sleep(2);
      System.out.println("Ready:      " +  System.nanoTime());
    }
    catch (InterruptedException e) {
      System.err.println("task interrupted");
    }
  };

  executor.scheduleWithFixedDelay(task, 0, 4, TimeUnit.SECONDS);
}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
@PostConstruct
private void postConstruct() {

  allEnvs = portalConfig.portalSupportedEnvs();

  for (Env env : allEnvs) {
    envStatusMark.put(env, true);
  }

  ScheduledExecutorService
      healthCheckService =
      Executors.newScheduledThreadPool(1, ApolloThreadFactory.create("EnvHealthChecker", false));

  healthCheckService
      .scheduleWithFixedDelay(new HealthCheckTask(applicationContext), 1000, HEALTH_CHECK_INTERVAL,
                              TimeUnit.MILLISECONDS);

}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
/**
 * 
 */
private void initCollectionTimer() {
    statScheduler = Executors.newScheduledThreadPool(1);
    statScheduler.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            lock.lock();
            try {
                //抓取kafka消费组信息
                fetchConsumerGroupFromKafkaAndZK();
                fetchProducerStatFromZK();
            } finally {
                lock.unlock();
            }
        }
    }, 1, 5, TimeUnit.SECONDS);
}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
public static void main(String[] args) {
    final LoadMonitor monitor = new LoadMonitor(null);
    final ScheduledExecutorService scheduler =
        Executors.newScheduledThreadPool(1);
    final ScheduledFuture<?> monitorTask =
        monitor.startMonitoring(scheduler);
    final ScheduledFuture<?> printTask =
        monitor.printMonitoring(scheduler);

    // Run the tasks for 2 minutes
    scheduler.schedule(
        new Runnable() {
            public void run() {
                monitorTask.cancel(true);
                printTask.cancel(true);
            }
        }, 5*60, TimeUnit.SECONDS);
}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
CachedWorkerPool(long keepAliveTime, TimeUnit unit) {
    this.keepAliveTime = unit != null ? unit.toNanos(keepAliveTime) : 0;
    this.expiringWorkerQueue = new ConcurrentLinkedQueue();
    this.allWorkers = new CompositeSubscription();
    ScheduledExecutorService evictor = null;
    Future<?> task = null;
    if (unit != null) {
        evictor = Executors.newScheduledThreadPool(1, CachedThreadScheduler.EVICTOR_THREAD_FACTORY);
        NewThreadWorker.tryEnableCancelPolicy(evictor);
        task = evictor.scheduleWithFixedDelay(new Runnable() {
            public void run() {
                CachedWorkerPool.this.evictExpiredWorkers();
            }
        }, this.keepAliveTime, this.keepAliveTime, TimeUnit.NANOSECONDS);
    }
    this.evictorService = evictor;
    this.evictorTask = task;
}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
MemStoreChunkPool(Configuration conf, int chunkSize, int maxCount,
    int initialCount) {
  this.maxCount = maxCount;
  this.chunkSize = chunkSize;
  this.reclaimedChunks = new LinkedBlockingQueue<Chunk>();
  for (int i = 0; i < initialCount; i++) {
    Chunk chunk = new Chunk(chunkSize);
    chunk.init();
    reclaimedChunks.add(chunk);
  }
  final String n = Thread.currentThread().getName();
  scheduleThreadPool = Executors.newScheduledThreadPool(1,
      new ThreadFactoryBuilder().setNameFormat(n+"-MemStoreChunkPool Statistics")
          .setDaemon(true).build());
  this.scheduleThreadPool.scheduleAtFixedRate(new StatisticsThread(this),
      statThreadPeriod, statThreadPeriod, TimeUnit.SECONDS);
}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
static void demo() {
	ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
	// 延迟3秒执行
	scheduledThreadPool.schedule(new Runnable() {
		public void run() {
			System.out.println("delay 3 seconds");
		}
	}, 3, TimeUnit.SECONDS);

	// 表示延迟1秒后每3秒执行一次
	scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
		public void run() {
			System.out.println("delay 1 seconds, and excute every 3 seconds");
		}
	}, 1, 3, TimeUnit.SECONDS);
}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
private static void test2() {
    ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
    Runnable task = () -> System.out.println("Scheduling: " + System.nanoTime());
    int initialDelay = 0;
    int period = 1;
    executor.scheduleAtFixedRate(task, initialDelay, period, TimeUnit.SECONDS);
}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
@Override
public void initialize() {

    api.registerforChangeEvents(this);
    ScheduledExecutorService executerPool = Executors.newScheduledThreadPool(1);
    executerPool.schedule(new InitializationRunnable(), 3, TimeUnit.SECONDS);
    updateStatus(ThingStatus.ONLINE);
    super.initialize();

}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
@Override
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay,
                                                 long delay, TimeUnit unit) {
    if (ses == null)
        ses = Executors.newScheduledThreadPool(1);
    try {
        return ses.scheduleWithFixedDelay(command, initialDelay, delay, unit);
    } catch (Exception e) {
        return new MockFuture<Object>(new ExecutionException(e));
    }
}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
private IOSScheduledExecutorPool() {
    executorService = Executors.newScheduledThreadPool(1, THREAD_FACTORY);
}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
public void initScheduleSync()
{
    // every 15 minutes create a thread to check for schedules to sync
    ScheduledExecutorService syncScheduler = Executors.newScheduledThreadPool(1);
    syncScheduler.scheduleAtFixedRate( new ScheduleSyncer(), 60*15, 60*15, TimeUnit.SECONDS );
}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
private ScheduledNotifier() {
    _pool = Executors.newScheduledThreadPool(1);
    init();
}
 

import java.util.concurrent.Executors; //导入方法依赖的package包/类
public void init() {
	executor = Executors.newScheduledThreadPool(1);
	future = executor.scheduleAtFixedRate(new TcpHeartBeat(this), keepAliveSeconds, keepAliveSeconds,
			TimeUnit.SECONDS);
	connect();
}