@Override public int getQueuedTaskCount(TaskPriority priority) { // subtract one from starvable count for hack task for spin issue return super.getQueuedTaskCount(priority) - (priority == TaskPriority.Starvable ? 1 : 0); }
@Override public void scheduleWithFixedDelay(Runnable task, long initialDelay, long recurringDelay) { scheduleWithFixedDelay(task, initialDelay, recurringDelay, null); }
@Override public <T> ListenableFuture<T> submit(Callable<T> task, TaskPriority priority) { return submitScheduled(task, 0, priority); }
@Override public int getQueuedTaskCount(TaskPriority priority) { if (priority == null) { return getQueuedTaskCount(); } return getQueueManager().getQueueSet(priority).queueSize(); }
/** * Changes the max wait time for low priority tasks. This is the amount of time that a low * priority task will wait if there are ready to execute high priority tasks. After a low * priority task has waited this amount of time, it will be executed fairly with high priority * tasks (meaning it will only execute the high priority task if it has been waiting longer than * the low priority task). * * @param maxWaitForLowPriorityInMs new wait time in milliseconds for low priority tasks during thread contention */ public void setMaxWaitForLowPriority(long maxWaitForLowPriorityInMs) { getQueueManager().setMaxWaitForLowPriority(maxWaitForLowPriorityInMs); }
@Override public int getWaitingForExecutionTaskCount(TaskPriority priority) { if (priority == null) { return getWaitingForExecutionTaskCount(); } QueueSet qs = getQueueManager().getQueueSet(priority); int result = qs.executeQueue.size(); for (int i = 0; i < qs.scheduleQueue.size(); i++) { try { if (qs.scheduleQueue.get(i).getScheduleDelay() > 0) { break; } else { result++; } } catch (IndexOutOfBoundsException e) { break; } } return result; }
@Override protected final void doSchedule(Runnable task, long delayInMillis) { doSchedule(task, delayInMillis, defaultPriority); }
private void removeRunnableTest(TaskPriority priority) { AbstractPrioritySchedulerFactory factory = getAbstractPrioritySchedulerFactory(); try { AbstractPriorityScheduler scheduler = factory.makeAbstractPriorityScheduler(1); TestRunnable removedTask = new TestRunnable(); scheduler.submitScheduled(removedTask, 10 * 1000, priority); assertFalse(scheduler.remove(new TestRunnable())); assertTrue(scheduler.remove(removedTask)); } finally { factory.shutdown(); } }
@Override public void run() { if (testRunning.get()) { while (scheduler.getQueueManager().getQueueSet(TaskPriority.High).executeQueue.size() < 5) { scheduler.execute(this, TaskPriority.High); } } } }.run();
private void removeRecurringRunnableTest(TaskPriority priority) { int runFrequency = 1; AbstractPrioritySchedulerFactory factory = getAbstractPrioritySchedulerFactory(); try { AbstractPriorityScheduler scheduler = factory.makeAbstractPriorityScheduler(1); TestRunnable removedTask = new TestRunnable(); TestRunnable keptTask = new TestRunnable(); scheduler.scheduleWithFixedDelay(removedTask, 0, runFrequency, priority); scheduler.scheduleWithFixedDelay(keptTask, 0, runFrequency, priority); removedTask.blockTillStarted(); assertFalse(scheduler.remove(new TestRunnable())); assertTrue(scheduler.remove(removedTask)); // verify removed is no longer running, and the kept task continues to run int keptRunCount = keptTask.getRunCount(); int runCount = removedTask.getRunCount(); TestUtils.sleep(runFrequency * 10); // may be +1 if the task was running while the remove was called assertTrue(removedTask.getRunCount() == runCount || removedTask.getRunCount() == runCount + 1); assertTrue(keptTask.getRunCount() >= keptRunCount); } finally { factory.shutdown(); } }
@Override public int getWaitingForExecutionTaskCount() { int result = 0; for (TaskPriority p : TaskPriority.values()) { result += getWaitingForExecutionTaskCount(p); } return result; }
@Override public void scheduleAtFixedRate(Runnable task, long initialDelay, long period) { scheduleAtFixedRate(task, initialDelay, period, null); }
@Override public void execute(Runnable task, TaskPriority priority) { schedule(task, 0, priority); }
@Test public void lowPriorityFlowControlTest() { AbstractPrioritySchedulerFactory priorityFactory = getAbstractPrioritySchedulerFactory(); final AtomicBoolean testRunning = new AtomicBoolean(true); try { final AbstractPriorityScheduler scheduler = priorityFactory.makeAbstractPriorityScheduler(1, TaskPriority.High, DELAY_TIME); new Runnable() { @Override public void run() { if (testRunning.get()) { while (scheduler.getQueueManager().getQueueSet(TaskPriority.High).executeQueue.size() < 5) { scheduler.execute(this, TaskPriority.High); } } } }.run(); TestRunnable lowPriorityRunnable = new TestRunnable(); scheduler.execute(lowPriorityRunnable, TaskPriority.Low); assertTrue(lowPriorityRunnable.getDelayTillFirstRun() >= DELAY_TIME); } finally { testRunning.set(false); priorityFactory.shutdown(); } }
@Override public int getQueuedTaskCount(TaskPriority priority) { if (priority == null) { return getQueuedTaskCount(); } return getQueueManager().getQueueSet(priority).queueSize(); }
@Override public long getMaxWaitForLowPriority() { return getQueueManager().getMaxWaitForLowPriority(); }
@Override public int getWaitingForExecutionTaskCount(TaskPriority priority) { if (priority == null) { return getWaitingForExecutionTaskCount(); } QueueSet qs = getQueueManager().getQueueSet(priority); int result = qs.executeQueue.size(); for (int i = 0; i < qs.scheduleQueue.size(); i++) { try { if (qs.scheduleQueue.get(i).getScheduleDelay() > 0) { break; } else { result++; } } catch (IndexOutOfBoundsException e) { break; } } return result; }
@Override protected final void doSchedule(Runnable task, long delayInMillis) { doSchedule(task, delayInMillis, defaultPriority); }
private void removeCallableTest(TaskPriority priority) { AbstractPrioritySchedulerFactory factory = getAbstractPrioritySchedulerFactory(); try { AbstractPriorityScheduler scheduler = factory.makeAbstractPriorityScheduler(1); TestCallable task = new TestCallable(); scheduler.submitScheduled(task, 1000 * 10, priority); assertFalse(scheduler.remove(new TestCallable())); assertTrue(scheduler.remove(task)); } finally { factory.shutdown(); } }
@Override public int getWaitingForExecutionTaskCount() { int result = 0; for (TaskPriority p : TaskPriority.values()) { result += getWaitingForExecutionTaskCount(p); } return result; }