Examples with ScheduledThreadPoolExecutor java.util.concurrent.ScheduledThreadPoolExecutor used on opensource projects

Example 36 with ScheduledThreadPoolExecutor

use of java.util.concurrent.ScheduledThreadPoolExecutor in project robovm by robovm.

the class ReferenceQueueTest method runLater.

private void runLater(Runnable runnable, int delayMillis) {
    ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
    executor.schedule(runnable, delayMillis, TimeUnit.MILLISECONDS);
    executor.shutdown();
}

Example 37 with ScheduledThreadPoolExecutor

use of java.util.concurrent.ScheduledThreadPoolExecutor in project guava by google.

the class MoreExecutorsTest method testGetScheduledExitingExcutorService_shutdownHookRegistered.

public void testGetScheduledExitingExcutorService_shutdownHookRegistered() throws InterruptedException {
    TestApplication application = new TestApplication();
    ScheduledThreadPoolExecutor executor = mock(ScheduledThreadPoolExecutor.class);
    ThreadFactory threadFactory = mock(ThreadFactory.class);
    when(executor.getThreadFactory()).thenReturn(threadFactory);
    ScheduledExecutorService unused = application.getExitingScheduledExecutorService(executor);
    application.shutdown();
    verify(executor).shutdown();
}

Example 38 with ScheduledThreadPoolExecutor

use of java.util.concurrent.ScheduledThreadPoolExecutor in project guava by google.

the class MoreExecutorsTest method testGetExitingScheduledExcutorService_executorDelegatesToOriginal.

public void testGetExitingScheduledExcutorService_executorDelegatesToOriginal() {
    TestApplication application = new TestApplication();
    ScheduledThreadPoolExecutor executor = mock(ScheduledThreadPoolExecutor.class);
    ThreadFactory threadFactory = mock(ThreadFactory.class);
    when(executor.getThreadFactory()).thenReturn(threadFactory);
    application.getExitingScheduledExecutorService(executor).execute(EMPTY_RUNNABLE);
    verify(executor).execute(EMPTY_RUNNABLE);
}

Example 39 with ScheduledThreadPoolExecutor

use of java.util.concurrent.ScheduledThreadPoolExecutor in project facebook-api-android-maven by avianey.

the class AppEventsLogger method initializeTimersIfNeeded.

private static void initializeTimersIfNeeded() {
    synchronized (staticLock) {
        if (backgroundExecutor != null) {
            return;
        }
        backgroundExecutor = new ScheduledThreadPoolExecutor(1);
    }
    final Runnable flushRunnable = new Runnable() {

        @Override
        public void run() {
            if (getFlushBehavior() != FlushBehavior.EXPLICIT_ONLY) {
                flushAndWait(FlushReason.TIMER);
            }
        }
    };
    backgroundExecutor.scheduleAtFixedRate(flushRunnable, 0, FLUSH_PERIOD_IN_SECONDS, TimeUnit.SECONDS);
    final Runnable attributionRecheckRunnable = new Runnable() {

        @Override
        public void run() {
            Set<String> applicationIds = new HashSet<String>();
            synchronized (staticLock) {
                for (AccessTokenAppIdPair accessTokenAppId : stateMap.keySet()) {
                    applicationIds.add(accessTokenAppId.getApplicationId());
                }
            }
            for (String applicationId : applicationIds) {
                Utility.queryAppSettings(applicationId, true);
            }
        }
    };
    backgroundExecutor.scheduleAtFixedRate(attributionRecheckRunnable, 0, APP_SUPPORTS_ATTRIBUTION_ID_RECHECK_PERIOD_IN_SECONDS, TimeUnit.SECONDS);
}

Example 40 with ScheduledThreadPoolExecutor

use of java.util.concurrent.ScheduledThreadPoolExecutor in project pulsar by yahoo.

the class ZookeeperCacheTest method testGlobalZooKeeperCache.

@Test
void testGlobalZooKeeperCache() throws Exception {
    OrderedSafeExecutor executor = new OrderedSafeExecutor(1, "test");
    ScheduledExecutorService scheduledExecutor = new ScheduledThreadPoolExecutor(1);
    MockZooKeeper zkc = MockZooKeeper.newInstance();
    ZooKeeperClientFactory zkClientfactory = new ZooKeeperClientFactory() {

        @Override
        public CompletableFuture<ZooKeeper> create(String serverList, SessionType sessionType, int zkSessionTimeoutMillis) {
            return CompletableFuture.completedFuture(zkc);
        }
    };
    GlobalZooKeeperCache zkCacheService = new GlobalZooKeeperCache(zkClientfactory, -1, "", executor, scheduledExecutor);
    zkCacheService.start();
    zkClient = (MockZooKeeper) zkCacheService.getZooKeeper();
    ZooKeeperDataCache<String> zkCache = new ZooKeeperDataCache<String>(zkCacheService) {

        @Override
        public String deserialize(String key, byte[] content) throws Exception {
            return new String(content);
        }
    };
    // Create callback counter
    AtomicInteger notificationCount = new AtomicInteger(0);
    ZooKeeperCacheListener<String> counter = (path, data, stat) -> {
        notificationCount.incrementAndGet();
    };
    // Register counter twice and unregister once, so callback should be counted correctly
    zkCache.registerListener(counter);
    zkCache.registerListener(counter);
    zkCache.unregisterListener(counter);
    String value = "test";
    zkClient.create("/my_test", value.getBytes(), null, null);
    assertEquals(zkCache.get("/my_test").get(), value);
    String newValue = "test2";
    // case 1: update and create znode directly and verify that the cache is retrieving the correct data
    assertEquals(notificationCount.get(), 0);
    zkClient.setData("/my_test", newValue.getBytes(), -1);
    zkClient.create("/my_test2", value.getBytes(), null, null);
    // Wait for the watch to be triggered
    while (notificationCount.get() < 1) {
        Thread.sleep(1);
    }
    // retrieve the data from the cache and verify it is the updated/new data
    assertEquals(zkCache.get("/my_test").get(), newValue);
    assertEquals(zkCache.get("/my_test2").get(), value);
    // The callback method should be called just only once
    assertEquals(notificationCount.get(), 1);
    // case 2: force the ZooKeeper session to be expired and verify that the data is still accessible
    zkCacheService.process(new WatchedEvent(Event.EventType.None, KeeperState.Expired, null));
    assertEquals(zkCache.get("/my_test").get(), newValue);
    assertEquals(zkCache.get("/my_test2").get(), value);
    // case 3: update the znode directly while the client session is marked as expired. Verify that the new updates
    // is not seen in the cache
    zkClient.create("/other", newValue.getBytes(), null, null);
    zkClient.failNow(Code.SESSIONEXPIRED);
    assertEquals(zkCache.get("/my_test").get(), newValue);
    assertEquals(zkCache.get("/my_test2").get(), value);
    try {
        zkCache.get("/other");
        fail("shuld have thrown exception");
    } catch (Exception e) {
    // Ok
    }
    // case 4: directly delete the znode while the session is not re-connected yet. Verify that the deletion is not
    // seen by the cache
    zkClient.failAfter(-1, Code.OK);
    zkClient.delete("/my_test2", -1);
    zkCacheService.process(new WatchedEvent(Event.EventType.None, KeeperState.SyncConnected, null));
    assertEquals(zkCache.get("/other").get(), newValue);
    // Make sure that the value is now directly from ZK and deleted
    assertFalse(zkCache.get("/my_test2").isPresent());
    // case 5: trigger a ZooKeeper disconnected event and make sure the cache content is not changed.
    zkCacheService.process(new WatchedEvent(Event.EventType.None, KeeperState.Disconnected, null));
    zkClient.create("/other2", newValue.getBytes(), null, null);
    // case 6: trigger a ZooKeeper SyncConnected event and make sure that the cache content is invalidated s.t. we
    // can see the updated content now
    zkCacheService.process(new WatchedEvent(Event.EventType.None, KeeperState.SyncConnected, null));
    // make sure that we get it
    assertEquals(zkCache.get("/other2").get(), newValue);
    zkCacheService.close();
    executor.shutdown();
    // Update shouldn't happen after the last check
    assertEquals(notificationCount.get(), 1);
}