/**
   * Adjusts adaptive poll frequency.
   *
   * @param pollInterval poll frequency in seconds
   */
  synchronized void adjustCalAndPollInterval(int pollInterval) {
    initMemberVars(pollInterval);

    if (calAndShortFlowsThread != null) {
      calAndShortFlowsThread.cancel(false);
    }
    if (midFlowsThread != null) {
      midFlowsThread.cancel(false);
    }
    if (longFlowsThread != null) {
      longFlowsThread.cancel(false);
    }

    calAndShortFlowsTask = new CalAndShortFlowsTask();
    calAndShortFlowsThread =
        adaptiveFlowStatsScheduler.scheduleWithFixedDelay(
            calAndShortFlowsTask, 0, calAndPollInterval, TimeUnit.SECONDS);

    midFlowsTask = new MidFlowsTask();
    midFlowsThread =
        adaptiveFlowStatsScheduler.scheduleWithFixedDelay(
            midFlowsTask, 0, midPollInterval, TimeUnit.SECONDS);

    longFlowsTask = new LongFlowsTask();
    longFlowsThread =
        adaptiveFlowStatsScheduler.scheduleWithFixedDelay(
            longFlowsTask, 0, longPollInterval, TimeUnit.SECONDS);

    log.debug("calAndPollInterval=" + calAndPollInterval + "is adjusted");
  }
  @Override
  public void contextInitialized(ServletContextEvent arg0) {
    smsCreatorScheduler = Executors.newSingleThreadScheduledExecutor();
    smsCreatorScheduler.scheduleWithFixedDelay(
        new SmsCreatorThread(),
        ParseUtil.sToL(processSchedulerConfig.get(Constants.PROP_SMS_CREATORL_INIT_DELAY)),
        ParseUtil.sToL(processSchedulerConfig.get(Constants.PROP_SMS_CREATOR_PROC_DELAY)),
        TimeUnit.SECONDS);
    schedulerLogging.info("smsCreatorScheduler  : startup context");

    smsSenderScheduler = Executors.newSingleThreadScheduledExecutor();
    smsSenderScheduler.scheduleWithFixedDelay(
        new SmsSenderThread(),
        ParseUtil.sToL(processSchedulerConfig.get(Constants.PROP_SMS_SENDER_INIT_DELAY)),
        ParseUtil.sToL(processSchedulerConfig.get(Constants.PROP_SMS_SENDER_PROC_DELAY)),
        TimeUnit.MINUTES);
    schedulerLogging.info("smsSenderScheduler  : startup context");

    mailScheduler = Executors.newSingleThreadScheduledExecutor();
    mailScheduler.scheduleWithFixedDelay(
        new SingleMailmanThread(),
        ParseUtil.sToL(processSchedulerConfig.get(Constants.PROP_STANNDARD_MAIL_INIT_DELAY)),
        ParseUtil.sToL(processSchedulerConfig.get(Constants.PROP_STANNDARD_MAIL_PROC_DELAY)),
        TimeUnit.SECONDS);
    schedulerLogging.info("mailScheduler  : startup context");

    mailCreator = Executors.newSingleThreadScheduledExecutor();
    mailCreator.scheduleWithFixedDelay(
        new EmailCreatorThread(),
        ParseUtil.sToL(processSchedulerConfig.get(Constants.PROP_EMAIL_CREATORL_INIT_DELAY)),
        ParseUtil.sToL(processSchedulerConfig.get(Constants.PROP_EMAIL_CREATOR_PROC_DELAY)),
        TimeUnit.SECONDS);
    schedulerLogging.info("mailCreator  : startup context");
  }
Beispiel #3
0
  public static void startSystem() throws ExecutionException, InterruptedException {

    // Create the entry gates and link them to the parking lot
    for (int i = 0; i < numOfEntries; i++) {
      entries.add(new Entry("entry" + i, parkingLot));
    }
    parkingLot.setEntries(entries);

    // Create the exit gates and link them to the parking lot
    for (int k = 0; k < numOfExits; k++) {
      exits.add(new Exit("exit" + k, parkingLot));
    }
    parkingLot.setExits(exits);

    // Create a thread pool based on the number of entries and exits for this lot
    ScheduledExecutorService scheduledExecutorService1 =
        Executors.newScheduledThreadPool(numOfEntries);
    ScheduledExecutorService scheduledExecutorService2 =
        Executors.newScheduledThreadPool(numOfExits);

    // Schedule the threads, which will act as Car objects entering and exiting the parking lot
    ScheduledFuture<?> scheduledFuture1 =
        scheduledExecutorService1.scheduleWithFixedDelay(
            new Car(entries, exits, 0), firstCarEntryTime, enteringCarsDelay, TimeUnit.SECONDS);

    ScheduledFuture<?> scheduledFuture2 =
        scheduledExecutorService2.scheduleWithFixedDelay(
            new Car(entries, exits, 1), firstCarExitTime, exitingCarsDelay, TimeUnit.SECONDS);

    scheduledFuture1.get();
    scheduledFuture2.get();
    scheduledExecutorService1.shutdown();
    scheduledExecutorService2.shutdown();
  }
  private StatsCollector(Map<String, String> configs) {
    ComponentLocator locator = ComponentLocator.getLocator(ManagementServer.Name);
    _agentMgr = locator.getManager(AgentManager.class);
    _userVmMgr = locator.getManager(UserVmManager.class);
    _hostDao = locator.getDao(HostDao.class);
    _userVmDao = locator.getDao(UserVmDao.class);
    _volsDao = locator.getDao(VolumeDao.class);
    _capacityDao = locator.getDao(CapacityDao.class);
    _storagePoolDao = locator.getDao(StoragePoolDao.class);
    _storageManager = locator.getManager(StorageManager.class);
    _storagePoolHostDao = locator.getDao(StoragePoolHostDao.class);

    _executor = Executors.newScheduledThreadPool(3, new NamedThreadFactory("StatsCollector"));

    hostStatsInterval = NumbersUtil.parseLong(configs.get("host.stats.interval"), 60000L);
    hostAndVmStatsInterval = NumbersUtil.parseLong(configs.get("vm.stats.interval"), 60000L);
    storageStatsInterval = NumbersUtil.parseLong(configs.get("storage.stats.interval"), 60000L);
    volumeStatsInterval = NumbersUtil.parseLong(configs.get("volume.stats.interval"), -1L);

    _executor.scheduleWithFixedDelay(
        new HostCollector(), 15000L, hostStatsInterval, TimeUnit.MILLISECONDS);
    _executor.scheduleWithFixedDelay(
        new VmStatsCollector(), 15000L, hostAndVmStatsInterval, TimeUnit.MILLISECONDS);
    _executor.scheduleWithFixedDelay(
        new StorageCollector(), 15000L, storageStatsInterval, TimeUnit.MILLISECONDS);

    // -1 means we don't even start this thread to pick up any data.
    if (volumeStatsInterval > 0) {
      _executor.scheduleWithFixedDelay(
          new VolumeCollector(), 15000L, volumeStatsInterval, TimeUnit.MILLISECONDS);
    } else {
      s_logger.info("Disabling volume stats collector");
    }
  }
  /** start adaptive flow statistic collection. */
  public synchronized void start() {
    log.debug("Starting AdaptiveStats collection thread for {}", sw.getStringId());
    callCountCalAndShortFlowsTask = 0;
    callCountMidFlowsTask = 0;
    callCountLongFlowsTask = 0;

    isFirstTimeStart = true;

    // Initially start polling quickly. Then drop down to configured value
    calAndShortFlowsTask = new CalAndShortFlowsTask();
    calAndShortFlowsThread =
        adaptiveFlowStatsScheduler.scheduleWithFixedDelay(
            calAndShortFlowsTask, 1, calAndPollInterval, TimeUnit.SECONDS);

    midFlowsTask = new MidFlowsTask();
    midFlowsThread =
        adaptiveFlowStatsScheduler.scheduleWithFixedDelay(
            midFlowsTask, 1, midPollInterval, TimeUnit.SECONDS);

    longFlowsTask = new LongFlowsTask();
    longFlowsThread =
        adaptiveFlowStatsScheduler.scheduleWithFixedDelay(
            longFlowsTask, 1, longPollInterval, TimeUnit.SECONDS);

    log.info("Started");
  }
Beispiel #6
0
 public void startTheJob() {
   final Runnable controllerEventsBatchProcessor = this::publishControllerPendingEvents;
   final Runnable ciEventsBatchProcessor = this::publishCIPendingEvents;
   jobHandle =
       controllerEventScheduler.scheduleWithFixedDelay(
           controllerEventsBatchProcessor, 0, 3, SECONDS);
   ciEventsJobHandle =
       ciEventScheduler.scheduleWithFixedDelay(ciEventsBatchProcessor, 0, 3, SECONDS);
 }
  public void run() throws Exception {
    for (Thread t : searcherThreads) {
      t.start();
    }
    for (Thread t : writerThreads) {
      t.start();
    }
    barrier1.await();

    Refresher refresher = new Refresher();
    scheduledExecutorService.scheduleWithFixedDelay(
        refresher, refreshSchedule.millis(), refreshSchedule.millis(), TimeUnit.MILLISECONDS);
    Flusher flusher = new Flusher();
    scheduledExecutorService.scheduleWithFixedDelay(
        flusher, flushSchedule.millis(), flushSchedule.millis(), TimeUnit.MILLISECONDS);

    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    barrier2.await();

    latch.await();
    stopWatch.stop();

    System.out.println("Summary");
    System.out.println(
        "   -- Readers ["
            + searcherThreads.length
            + "] with ["
            + searcherIterations
            + "] iterations");
    System.out.println(
        "   -- Writers [" + writerThreads.length + "] with [" + writerIterations + "] iterations");
    System.out.println("   -- Took: " + stopWatch.totalTime());
    System.out.println(
        "   -- Refresh [" + refresher.id + "] took: " + refresher.stopWatch.totalTime());
    System.out.println("   -- Flush [" + flusher.id + "] took: " + flusher.stopWatch.totalTime());
    System.out.println("   -- Store size " + store.estimateSize());

    scheduledExecutorService.shutdown();

    engine.refresh(new Engine.Refresh(true));
    stopWatch = new StopWatch();
    stopWatch.start();
    Engine.Searcher searcher = engine.searcher();
    TopDocs topDocs = searcher.searcher().search(new MatchAllDocsQuery(), idGenerator.get() + 1);
    stopWatch.stop();
    System.out.println(
        "   -- Indexed ["
            + idGenerator.get()
            + "] docs, found ["
            + topDocs.totalHits
            + "] hits, took "
            + stopWatch.totalTime());
    searcher.release();
  }
    // Start moving the BubbleView & updating the display
    private void start() {

      // Creates a WorkerThread
      ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

      // Execute the run() in Worker Thread every REFRESH_RATE
      // milliseconds
      // Save reference to this job in mMoverFuture
      mMoverFuture =
          executor.scheduleWithFixedDelay(
              new Runnable() {
                @Override
                public void run() {

                  // implement movement logic.
                  // Each time this method is run the BubbleView should
                  // move one step. If the BubbleView exits the display,
                  // stop the BubbleView's Worker Thread.
                  // Otherwise, request that the BubbleView be redrawn.

                  boolean exits = moveWhileOnScreen();
                  if (exits) {
                    stop(false);
                  } else {
                    BubbleView.this.postInvalidate();
                  }
                }
              },
              0,
              REFRESH_RATE,
              TimeUnit.MILLISECONDS);
    }
  /**
   * DOCUMENT ME!
   *
   * @param watchable rootResource DOCUMENT ME!
   */
  public void submit(final Watchable watchable) {
    final Deregister deregister = new Deregister();
    final Runnable poll = new Poll(deregister, watchable);

    final ScheduledFuture future = poller.scheduleWithFixedDelay(poll, 30, 30, TimeUnit.SECONDS);
    deregister.self = future;
  }
  @Activate
  public void activate(ComponentContext context) {
    configService.registerProperties(getClass());

    idGenerator = coreService.getIdGenerator(FlowRuleService.FLOW_OP_TOPIC);

    local = clusterService.getLocalNode().id();

    messageHandlingExecutor =
        Executors.newFixedThreadPool(
            msgHandlerPoolSize, groupedThreads("onos/store/flow", "message-handlers"));

    registerMessageHandlers(messageHandlingExecutor);

    if (backupEnabled) {
      replicaInfoManager.addListener(flowTable);
      backupTask =
          backupSenderExecutor.scheduleWithFixedDelay(
              flowTable::backup, 0, backupPeriod, TimeUnit.MILLISECONDS);
    }

    deviceTableStats =
        storageService
            .<DeviceId, List<TableStatisticsEntry>>eventuallyConsistentMapBuilder()
            .withName("onos-flow-table-stats")
            .withSerializer(SERIALIZER_BUILDER)
            .withAntiEntropyPeriod(5, TimeUnit.SECONDS)
            .withTimestampProvider((k, v) -> new WallClockTimestamp())
            .withTombstonesDisabled()
            .build();
    deviceTableStats.addListener(tableStatsListener);

    logConfig("Started");
  }
  /** @param defaultExpiration the TTL for objects in the cache in milliseconds */
  public ExpiringMap(long defaultExpiration, final Function<Pair<K, V>, ?> postExpireHook) {
    this.defaultExpiration = defaultExpiration;

    if (defaultExpiration <= 0) {
      throw new IllegalArgumentException("Argument specified must be a positive number");
    }

    Runnable runnable =
        new Runnable() {
          public void run() {
            long start = System.currentTimeMillis();
            int n = 0;
            for (Map.Entry<K, CacheableObject<V>> entry : cache.entrySet()) {
              if (entry.getValue().isReadyToDieAt(start)) {
                cache.remove(entry.getKey());
                n++;
                if (postExpireHook != null)
                  postExpireHook.apply(new Pair<K, V>(entry.getKey(), entry.getValue().getValue()));
              }
            }
            logger.trace("Expired {} entries", n);
          }
        };
    service.scheduleWithFixedDelay(
        runnable, defaultExpiration / 2, defaultExpiration / 2, TimeUnit.MILLISECONDS);
  }
  @SuppressWarnings({"rawtypes", "unchecked"})
  public void testMonitorAndContinueWithoutTimeout() {
    ScheduledFuture mockFuture = EasyMock.createMock(ScheduledFuture.class);
    ScheduledExecutorService schedulerMock = EasyMock.createMock(ScheduledExecutorService.class);
    expect(
            schedulerMock.scheduleWithFixedDelay(
                anyObject(Runnable.class), anyLong(), anyLong(), anyObject(TimeUnit.class)))
        .andReturn(mockFuture);

    replay(mockFuture);
    replay(schedulerMock);

    CoutingEventHandler handler = new CoutingEventHandler();
    EventBus eventBus = new EventBus();
    eventBus.register(handler);

    AsyncMonitor<Object> monitor =
        mockMonitor(schedulerMock, new Object(), mockFunction(MonitorStatus.CONTINUE), eventBus);

    assertNull(monitor.getFuture());
    assertNull(monitor.getTimeout());

    monitor.startMonitoring(null);
    assertNotNull(monitor.getFuture());
    assertNull(monitor.getTimeout());

    monitor.run();
    assertEquals(handler.numCompletes, 0);
    assertEquals(handler.numFailures, 0);
    assertEquals(handler.numTimeouts, 0);

    verify(mockFuture);
    verify(schedulerMock);
  }
  @SuppressWarnings({"rawtypes", "unchecked"})
  public void testStartMonitoringWithTimeout() {
    ScheduledFuture mockFuture = EasyMock.createMock(ScheduledFuture.class);
    ScheduledExecutorService schedulerMock = EasyMock.createMock(ScheduledExecutorService.class);
    expect(
            schedulerMock.scheduleWithFixedDelay(
                anyObject(Runnable.class), anyLong(), anyLong(), anyObject(TimeUnit.class)))
        .andReturn(mockFuture);

    replay(mockFuture);
    replay(schedulerMock);

    AsyncMonitor<Object> monitor =
        mockMonitor(schedulerMock, new Object(), mockFunction(MonitorStatus.DONE), new EventBus());

    assertNull(monitor.getFuture());
    assertNull(monitor.getTimeout());

    monitor.startMonitoring(100L);

    assertNotNull(monitor.getFuture());
    assertNotNull(monitor.getTimeout());
    assertTrue(monitor.getTimeout() > 100L);

    verify(mockFuture);
    verify(schedulerMock);
  }
Beispiel #14
0
  @Override
  public void start() {
    logger.info("Starting {}...", this);

    Responder responder = new SpecificResponder(AvroSourceProtocol.class, this);
    if (maxThreads <= 0) {
      server = new NettyServer(responder, new InetSocketAddress(bindAddress, port));
    } else {
      server =
          new NettyServer(
              responder,
              new InetSocketAddress(bindAddress, port),
              new NioServerSocketChannelFactory(
                  Executors.newCachedThreadPool(), Executors.newFixedThreadPool(maxThreads)));
    }
    connectionCountUpdater = Executors.newSingleThreadScheduledExecutor();
    server.start();
    sourceCounter.start();
    super.start();
    final NettyServer srv = (NettyServer) server;
    connectionCountUpdater.scheduleWithFixedDelay(
        new Runnable() {

          @Override
          public void run() {
            sourceCounter.setOpenConnectionCount(Long.valueOf(srv.getNumActiveConnections()));
          }
        },
        0,
        60,
        TimeUnit.SECONDS);

    logger.info("Avro source {} started.", getName());
  }
  protected final void scrollBy(float velocityY) {
    cancelFuture();

    mFuture =
        mExecutor.scheduleWithFixedDelay(
            new InertiaTimerTask(this, velocityY), 0, VELOCITYFLING, TimeUnit.MILLISECONDS);
  }
  {
    ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();

    updateDetectorFuture =
        executor.scheduleWithFixedDelay(
            new StatusUpdateDetector(), 5, POLL_PERIOD, TimeUnit.SECONDS);
  }
  public synchronized void startIndexing() {
    stopIndexing(); // stop executors if they are already running, otherwise they will never stop
    if (registryConfig.IsStartIndexing()) {
      submittingExecutor = Executors.newSingleThreadScheduledExecutor();
      submittingExecutor.scheduleWithFixedDelay(
          new ResourceSubmitter(this),
          getStartingDelayInSecs(),
          getIndexingFreqInSecs(),
          TimeUnit.SECONDS);

      indexingExecutor = Executors.newSingleThreadScheduledExecutor();
      indexingExecutor.scheduleWithFixedDelay(
          indexer, getStartingDelayInSecs(), getIndexingFreqInSecs(), TimeUnit.SECONDS);
      readLastAccessTime();
    }
  }
  public static void main(String[] args) throws Exception {

    BasicConfigurator.configure();

    String username = "******";

    final String TWITTER_OAUTH_KEY = "";
    final String TWITTER_OAUTH_SECRET = "";
    final String ACCESS_TOKEN = "";
    final String ACCESS_TOKEN_SECRET = "";

    OAuthSignpostClient oauth =
        new OAuthSignpostClient(
            TWITTER_OAUTH_KEY, TWITTER_OAUTH_SECRET, ACCESS_TOKEN, ACCESS_TOKEN_SECRET);
    TwitterClient twitter = new TwitterClient(username, oauth);

    Connection conn =
        DriverManager.getConnection("jdbc:postgresql://juergenbickert.de:5432/smsd?user=smsd");
    conn.setAutoCommit(false);
    conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);

    SmsProvider smsProvider = new SmsProvider(conn);

    TwitterTask task = new TwitterTask(twitter, smsProvider);
    task.setAppend(" #tmn12");

    ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);

    pool.scheduleWithFixedDelay(task, 0, 1, TimeUnit.SECONDS);
  }
  /**
   * Submits or schedules an {@link ApplicationTask} on the the shared executor service.
   *
   * @param task The task
   * @param delay Initial delay in milliseconds, or zero for ASAP
   * @param repeatEvery Repeat delay in milliseconds, or zero for no repetition
   * @param fixedRepeat Whether repetitions are at fixed times, or if the repeat delay begins when
   *     the task ends
   * @return A future for the task
   */
  private <T> Future<T> task(
      ApplicationTask<T> task, int delay, int repeatEvery, boolean fixedRepeat) {
    ExecutorService executor = getExecutor();
    if ((delay > 0) || (repeatEvery > 0)) {
      if (!(executor instanceof ScheduledExecutorService))
        throw new RuntimeException(
            "Executor must implement the ScheduledExecutorService interface to allow for delayed tasks");

      ScheduledExecutorService scheduledExecutor = (ScheduledExecutorService) executor;
      if (repeatEvery > 0) {
        if (fixedRepeat) {
          @SuppressWarnings("unchecked")
          ScheduledFuture<T> future =
              (ScheduledFuture<T>)
                  scheduledExecutor.scheduleAtFixedRate(
                      task, delay, repeatEvery, TimeUnit.MILLISECONDS);
          return future;
        } else {
          @SuppressWarnings("unchecked")
          ScheduledFuture<T> future =
              (ScheduledFuture<T>)
                  scheduledExecutor.scheduleWithFixedDelay(
                      task, delay, repeatEvery, TimeUnit.MILLISECONDS);
          return future;
        }
      } else return scheduledExecutor.schedule((Callable<T>) task, delay, TimeUnit.MILLISECONDS);
    } else return executor.submit((Callable<T>) task);
  }
  void startBackgroundInvalidate() {
    if (isScheduled.get()) {
      throw new IllegalStateException("already scheduled");
    }
    if (!isScheduled.compareAndSet(false, true)) {
      throw new IllegalStateException("already scheduled");
    }

    taskExecutor =
        Executors.newScheduledThreadPool(
            config.getInvalidateThreads(),
            new NameableDaemonThreadFactory(AsyncInvalidateThread.class.getSimpleName()));

    InvalidateTaskBootstrap bootstrap = new InvalidateTaskBootstrap();
    taskExecutor.scheduleWithFixedDelay(
        bootstrap,
        config.getInvalidateThreadInitialDelayMillis(),
        config.getInvalidateIntervalMillis(),
        TimeUnit.MILLISECONDS);

    Runtime.getRuntime()
        .addShutdownHook(
            new Thread(
                new Runnable() {
                  @Override
                  public void run() {
                    taskExecutor.shutdownNow();
                  }
                }));
  }
Beispiel #21
0
 public Shutdown start(
     final Builder builder,
     final int intervalMillis,
     final int repetitions,
     final AutomaticFuture automaticFuture) {
   synchronized (this) {
     if (shutdown) {
       return new Shutdown() {
         @Override
         public BaseFuture shutdown() {
           return new FutureDone<Void>().done();
         }
       };
     }
     final CountDownLatch latch = new CountDownLatch(1);
     final DirectReplicationWorker worker =
         new DirectReplicationWorker(builder, automaticFuture, repetitions, latch);
     ScheduledFuture<?> future =
         scheduledExecutorService.scheduleWithFixedDelay(
             worker, 0, intervalMillis, TimeUnit.MILLISECONDS);
     worker.future = future;
     latch.countDown();
     return new Shutdown() {
       @Override
       public BaseFuture shutdown() {
         worker.shutdown();
         return new FutureDone<Void>().done();
       }
     };
   }
 }
  public JobLoggerDelegate(Config config) {
    JobLoggerFactory jobLoggerFactory =
        ExtensionLoader.getExtensionLoader(JobLoggerFactory.class).getAdaptiveExtension();
    jobLogger = jobLoggerFactory.getJobLogger(config);
    lazyLog = config.getParameter(Constants.LAZY_JOB_LOGGER, false);
    if (lazyLog) {

      // 无界Queue
      memoryQueue = new LinkedBlockingQueue<JobLogPo>();
      maxMemoryLogSize = config.getParameter(Constants.LAZY_JOB_LOGGER_MEM_SIZE, 1000);
      flushPeriod = config.getParameter(Constants.LAZY_JOB_LOGGER_CHECK_PERIOD, 3);

      executor =
          Executors.newSingleThreadScheduledExecutor(new NamedThreadFactory("LazyJobLogger"));
      scheduledFuture =
          executor.scheduleWithFixedDelay(
              new Runnable() {
                @Override
                public void run() {
                  try {
                    if (flushing.compareAndSet(false, true)) {
                      checkAndFlush();
                    }
                  } catch (Throwable t) {
                    LOGGER.error("CheckAndFlush log error", t);
                  }
                }
              },
              flushPeriod,
              flushPeriod,
              TimeUnit.SECONDS);
    }
  }
Beispiel #23
0
  private void _initCommitScheduler() {
    if ((PropsValues.LUCENE_COMMIT_BATCH_SIZE <= 0)
        || (PropsValues.LUCENE_COMMIT_TIME_INTERVAL <= 0)) {

      return;
    }

    ScheduledExecutorService scheduledExecutorService =
        Executors.newSingleThreadScheduledExecutor();

    Runnable runnable =
        new Runnable() {

          @Override
          public void run() {
            try {
              if (_batchCount > 0) {
                _doCommit();
              }
            } catch (IOException ioe) {
              _log.error("Could not run scheduled commit", ioe);
            }
          }
        };

    scheduledExecutorService.scheduleWithFixedDelay(
        runnable, 0, PropsValues.LUCENE_COMMIT_TIME_INTERVAL, TimeUnit.MILLISECONDS);
  }
Beispiel #24
0
 /**
  * Create the structure to enable submission by database
  *
  * @throws WaarpDatabaseNoConnectionException
  * @throws WaarpDatabaseSqlException
  */
 public InternalRunner() throws WaarpDatabaseNoConnectionException, WaarpDatabaseSqlException {
   if (DbConstant.admin.isActive()) {
     commander = new Commander(this, true);
   } else {
     commander = new CommanderNoDb(this, true);
   }
   scheduledExecutorService =
       Executors.newSingleThreadScheduledExecutor(new WaarpThreadFactory("InternalRunner"));
   isRunning = true;
   BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(10);
   threadPoolExecutor =
       new ThreadPoolExecutor(
           10,
           Configuration.configuration.getRUNNER_THREAD(),
           1000,
           TimeUnit.MILLISECONDS,
           workQueue);
   scheduledFuture =
       scheduledExecutorService.scheduleWithFixedDelay(
           commander,
           Configuration.configuration.getDelayCommander(),
           Configuration.configuration.getDelayCommander(),
           TimeUnit.MILLISECONDS);
   networkTransaction = new NetworkTransaction();
 }
  @Override
  public void init() {
    super.init();
    eventBus = new EventBus(this);
    eventBus.addRegistrationListener(
        new ResourceRegistrationListener() {

          @Override
          public void resourceUnregistered(String uuid) {
            System.out.println("Unregistered " + uuid);
          }

          @Override
          public void resourceRegistered(String uuid, Page page) {
            System.out.println("Registered " + uuid);
          }
        });

    ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    final Runnable beeper =
        new Runnable() {
          @Override
          public void run() {
            try {
              eventBus.post(new Date());
            } catch (Exception e) {
              e.printStackTrace();
            }
          }
        };
    scheduler.scheduleWithFixedDelay(beeper, 2, 2, TimeUnit.SECONDS);
  }
 public void run() {
   while (true) {
     try {
       ThEvent event = queue.take(); // 获取并移除此队列的头,如果此队列为空,则返回 null。
       size++;
       process(event);
       long curTime = System.currentTimeMillis();
       if (size == batchSize || ((curTime - lastTime) > batchTime)) {
         int temp = size;
         if (temp > 0) {
           size = 0;
           if (flag) {
             ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
             Runnable hbase = new HbaseStorageTask(hbaseService.getTable(), "event");
             // hbase.run(); // 首次启动初始化缓存
             service.scheduleWithFixedDelay(hbase, 1, 10, TimeUnit.SECONDS);
             flag = false;
           }
         }
         log.info(
             "批量存储驾驶事件数据信息----提交:[{}]条, 耗时:[{}]ms", temp, (System.currentTimeMillis() - lastTime));
         lastTime = System.currentTimeMillis();
       }
     } catch (Exception e) {
       log.error("存储驾驶事件数据异常:" + e.getMessage(), e);
     }
   }
 }
  public AbstractRedisRegistry(URL url) {
    super(url);
    RedisRegistryUtil.assertNotAnyHost(url);
    GenericObjectPoolConfig config = RedisRegistryUtil.genericObjectPoolConfig(url);
    List<String> addresses = RedisRegistryUtil.getAddresses(url);

    for (String address : addresses) {
      JedisPool jedisPool = RedisRegistryUtil.initJedisPoolAndCheck(url, config, address);
      jedisPools.put(address, jedisPool);
    }

    this.replicate = RedisRegistryUtil.getReplicate(url);
    this.reconnectPeriod =
        url.getParameter(
            Constants.REGISTRY_RECONNECT_PERIOD_KEY, Constants.DEFAULT_REGISTRY_RECONNECT_PERIOD);
    this.root = RedisRegistryUtil.getGroup(url);
    this.expirePeriod =
        url.getParameter(Constants.SESSION_TIMEOUT_KEY, Constants.DEFAULT_SESSION_TIMEOUT);
    this.expireFuture =
        expireExecutor.scheduleWithFixedDelay(
            new Runnable() {
              public void run() {
                try {
                  deferExpired(); // 延长过期时间
                } catch (Throwable t) { // 防御性容错
                  logger.error(
                      "Unexpected exception occur at defer expire time, cause: " + t.getMessage(),
                      t);
                }
              }
            },
            expirePeriod / 2,
            expirePeriod / 2,
            TimeUnit.MILLISECONDS);
  }
 public void start() throws Exception {
   if (!isStarted()) {
     LOG.info("Starting server Plugin Registry...");
     scheduledExecutor = Executors.newScheduledThreadPool(2, new KEWThreadFactory());
     sharedPluginDirectory = loadSharedPlugin();
     reloader = new Reloader();
     hotDeployer = new HotDeployer(this, sharedPluginDirectory, pluginDirectories);
     loadPlugins(sharedPluginDirectory);
     this.reloaderFuture =
         scheduledExecutor.scheduleWithFixedDelay(reloader, 5, 5, TimeUnit.SECONDS);
     this.hotDeployerFuture =
         scheduledExecutor.scheduleWithFixedDelay(hotDeployer, 5, 5, TimeUnit.SECONDS);
     super.start();
     LOG.info("...server Plugin Registry successfully started.");
   }
 }
Beispiel #29
0
    // Start moving the BubbleView & updating the display
    private void startMovement() {

      // Creates a WorkerThread
      ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

      // Execute the run() in Worker Thread every REFRESH_RATE
      // milliseconds
      // Save reference to this job in mMoverFuture
      mMoverFuture =
          executor.scheduleWithFixedDelay(
              new Runnable() {
                @Override
                public void run() {

                  // Each time this method is run the BubbleView should
                  // move one step. If the BubbleView exits the display,
                  // stop the BubbleView's Worker Thread.
                  // Otherwise, request that the BubbleView be redrawn.
                  while (moveWhileOnScreen()) {
                    postInvalidate();
                    try {
                      Thread.sleep(1000);
                    } catch (InterruptedException e) {
                      mFrame.removeView(BubbleView.this);
                    }
                  }
                  stopMovement(false);
                }
              },
              0,
              REFRESH_RATE,
              TimeUnit.MILLISECONDS);
    }
  @Test
  public void testClientInactivity() throws Exception {
    long maxInactivityPeriod = 4000;
    bayeux.addExtension(
        new ActivityExtension(ActivityExtension.Activity.CLIENT, maxInactivityPeriod));

    scheduler.scheduleWithFixedDelay(
        new Runnable() {
          public void run() {
            bayeux.getChannel(channelName).publish(null, "test");
          }
        },
        0,
        timeout / 4,
        TimeUnit.MILLISECONDS);

    final BayeuxClient client = newBayeuxClient();
    client
        .getChannel(Channel.META_HANDSHAKE)
        .addListener(
            new ClientSessionChannel.MessageListener() {
              public void onMessage(ClientSessionChannel channel, Message message) {
                if (message.isSuccessful()) {
                  client
                      .getChannel(channelName)
                      .subscribe(
                          new ClientSessionChannel.MessageListener() {
                            public void onMessage(ClientSessionChannel channel, Message message) {}
                          });
                }
              }
            });

    final CountDownLatch latch = new CountDownLatch(2);
    client
        .getChannel(Channel.META_CONNECT)
        .addListener(
            new ClientSessionChannel.MessageListener() {
              public void onMessage(ClientSessionChannel channel, Message message) {
                Map<String, Object> advice = message.getAdvice();
                if (advice != null
                    && Message.RECONNECT_NONE_VALUE.equals(advice.get(Message.RECONNECT_FIELD))) {
                  latch.countDown();
                }
              }
            });
    client
        .getChannel(Channel.META_DISCONNECT)
        .addListener(
            new ClientSessionChannel.MessageListener() {
              public void onMessage(ClientSessionChannel channel, Message message) {
                latch.countDown();
              }
            });

    client.handshake();

    Assert.assertTrue(latch.await(2 * maxInactivityPeriod, TimeUnit.MILLISECONDS));
  }