@Override protected SchedulerServiceLimiter getLimiter(int parallelCount, boolean limitFutureListenersExecution) { return new SchedulerServiceLimiter(scheduler, parallelCount, limitFutureListenersExecution); }
/** * Removes the runnable task from the execution queue. It is possible for the runnable to still * run until this call has returned. * <p> * See also: {@link SchedulerService#remove(Callable)} * * @param task The original task provided to the executor * @return {@code true} if the task was found and removed */ public boolean remove(Callable<?> task) { for (LimiterContainer limiter : currentLimiters.values()) { if (limiter.limiter.remove(task)) { limiter.handlingTasks.decrementAndGet(); return true; } } return false; }
@Test public void removeRunningRecurringMultipleInstancesTest() { BlockingTestRunnable btr = new BlockingTestRunnable(); try { SchedulerServiceLimiter limiter = getLimiter(1, true); limiter.scheduleAtFixedRate(btr, 0, 100); btr.blockTillStarted(); // a couple others that we should be able to remove individually limiter.scheduleAtFixedRate(btr, 0, 100); limiter.execute(btr); assertEquals(2, limiter.getQueuedTaskCount()); assertTrue(limiter.remove(btr)); assertEquals(2, limiter.getQueuedTaskCount()); assertTrue(limiter.remove(btr)); assertEquals(1, limiter.getQueuedTaskCount()); assertTrue(limiter.remove(btr)); assertEquals(0, limiter.getQueuedTaskCount()); } finally { btr.unblock(); } }
@Test public void removeRunnableFromQueueTest() { BlockingTestRunnable btr = new BlockingTestRunnable(); try { SchedulerServiceLimiter limiter = getLimiter(1, true); limiter.execute(btr); TestRunnable tr = new TestRunnable(); assertFalse(limiter.remove(tr)); limiter.submit(tr); // verify it is in queue assertTrue(limiter.waitingTasks.size() >= 1); assertTrue(limiter.remove(tr)); } finally { btr.unblock(); } }
@Test public void isShutdownTest() { PriorityScheduler executor = new StrictPriorityScheduler(1); try { SchedulerServiceLimiter limiter = new SchedulerServiceLimiter(executor, 1); assertFalse(limiter.isShutdown()); executor.shutdownNow(); assertTrue(limiter.isShutdown()); } finally { executor.shutdownNow(); } }
@Test public void removeRunningRecurringFixedRateTask() { BlockingTestRunnable btr = new BlockingTestRunnable(); try { SchedulerServiceLimiter limiter = getLimiter(1, true); limiter.scheduleAtFixedRate(btr, 0, 100); btr.blockTillStarted(); assertTrue(limiter.remove(btr)); } finally { btr.unblock(); } }
@Test public void removeRunningRecurringFixedDelayTask() { BlockingTestRunnable btr = new BlockingTestRunnable(); try { SchedulerServiceLimiter limiter = getLimiter(1, true); limiter.scheduleWithFixedDelay(btr, 0, 100); btr.blockTillStarted(); assertTrue(limiter.remove(btr)); } finally { btr.unblock(); } }
@Test public void executeLimitQueueTest() { SchedulerServiceLimiter limitedExecutor = getLimiter(PARALLEL_COUNT, true); List<BlockingTestRunnable> blockingRunnables = new ArrayList<>(PARALLEL_COUNT); try { for (int i = 0; i < PARALLEL_COUNT; i++) { BlockingTestRunnable btr = new BlockingTestRunnable(); limitedExecutor.execute(btr); blockingRunnables.add(btr); } for (BlockingTestRunnable btr : blockingRunnables) { btr.blockTillStarted(); } assertEquals(0, limitedExecutor.getQueuedTaskCount()); limitedExecutor.execute(DoNothingRunnable.instance()); TestUtils.sleep(DELAY_TIME); assertEquals(1, limitedExecutor.getQueuedTaskCount()); } finally { for (BlockingTestRunnable btr : blockingRunnables) { btr.unblock(); } } }
@Test public void removeCallableFromQueueTest() { BlockingTestRunnable btr = new BlockingTestRunnable(); try { SchedulerServiceLimiter limiter = getLimiter(1, true); limiter.execute(btr); TestCallable tc = new TestCallable(); assertFalse(limiter.remove(tc)); limiter.submit(tc); // verify it is in queue assertTrue(limiter.waitingTasks.size() >= 1); assertTrue(limiter.remove(tc)); } finally { btr.unblock(); } }
@Override public SchedulerService makeSchedulerService(int poolSize, boolean prestartIfAvailable) { SchedulerService scheduler = schedulerFactory.makeSchedulerService(poolSize, prestartIfAvailable); int limiterAmount = Math.min(minLimiterAmount, poolSize); return new SchedulerServiceLimiter(scheduler, limiterAmount); } }
/** * Removes the runnable task from the execution queue. It is possible for the runnable to still * run until this call has returned. * <p> * See also: {@link SchedulerService#remove(Runnable)} * * @param task The original task provided to the executor * @return {@code true} if the task was found and removed */ public boolean remove(Runnable task) { for (LimiterContainer limiter : currentLimiters.values()) { if (limiter.limiter.remove(task)) { limiter.handlingTasks.decrementAndGet(); return true; } } return false; }
@Override protected SchedulerServiceLimiter makeLimiter(String limiterThreadName) { return new SchedulerServiceLimiter(StringUtils.isNullOrEmpty(limiterThreadName) ? scheduler : new ThreadRenamingSchedulerService(scheduler, limiterThreadName, false), getMaxConcurrencyPerKey(), limitFutureListenersExecution); }
/** * Removes the runnable task from the execution queue. It is possible for the runnable to still * run until this call has returned. * <p> * See also: {@link SchedulerService#remove(Callable)} * * @param task The original task provided to the executor * @return {@code true} if the task was found and removed */ public boolean remove(Callable<?> task) { for (LimiterContainer limiter : currentLimiters.values()) { if (limiter.limiter.remove(task)) { limiter.handlingTasks.decrementAndGet(); return true; } } return false; }
@Override protected SchedulerServiceLimiter makeLimiter(String limiterThreadName) { return new SchedulerServiceLimiter(StringUtils.isNullOrEmpty(limiterThreadName) ? scheduler : new ThreadRenamingSchedulerService(scheduler, limiterThreadName, false), getMaxConcurrencyPerKey(), limitFutureListenersExecution); }
/** * Removes the runnable task from the execution queue. It is possible for the runnable to still * run until this call has returned. * <p> * See also: {@link SchedulerService#remove(Runnable)} * * @param task The original task provided to the executor * @return {@code true} if the task was found and removed */ public boolean remove(Runnable task) { for (LimiterContainer limiter : currentLimiters.values()) { if (limiter.limiter.remove(task)) { limiter.handlingTasks.decrementAndGet(); return true; } } return false; }
@Test @Override @SuppressWarnings("unused") public void constructorFail() { try { new SchedulerServiceLimiter(null, 100); fail("Exception should have thrown"); } catch (IllegalArgumentException e) { // expected } try { new SchedulerServiceLimiter(scheduler, 0); fail("Exception should have thrown"); } catch (IllegalArgumentException e) { // expected } }