/** * Adds the ready TaskWrapper to the correct schedule queue. Using the priority specified in the * task, we pick the correct queue and add it. * <p> * If this is just a single execution with no delay use {@link #addToExecuteQueue(OneTimeTaskWrapper)}. * * @param task {@link TaskWrapper} to queue for the scheduler */ protected void addToScheduleQueue(QueueSet queueSet, TaskWrapper task) { if (workerPool.isShutdownStarted()) { throw new RejectedExecutionException("Thread pool shutdown"); } queueSet.addScheduled(task); }
/** * Adds the ready TaskWrapper to the correct schedule queue. Using the priority specified in the * task, we pick the correct queue and add it. * <p> * If this is just a single execution with no delay use {@link #addToExecuteQueue(OneTimeTaskWrapper)}. * * @param task {@link TaskWrapper} to queue for the scheduler */ protected void addToScheduleQueue(QueueSet queueSet, TaskWrapper task) { if (workerPool.isShutdownStarted()) { throw new RejectedExecutionException("Thread pool shutdown"); } queueSet.addScheduled(task); }
@Test public void addScheduledOrderTest() { List<TaskWrapper> orderedList = new ArrayList<>(TEST_QTY); for (int i = 0; i < TEST_QTY; i++) { orderedList.add(new OneTimeTaskWrapper(DoNothingRunnable.instance(), null, Clock.accurateForwardProgressingMillis() + i)); } List<TaskWrapper> randomList = new ArrayList<>(orderedList); Collections.shuffle(randomList); Iterator<TaskWrapper> it = randomList.iterator(); while (it.hasNext()) { queueSet.addScheduled(it.next()); } Iterator<TaskWrapper> expectedIt = orderedList.iterator(); Iterator<TaskWrapper> resultIt = queueSet.scheduleQueue.iterator(); while (expectedIt.hasNext()) { assertTrue(expectedIt.next() == resultIt.next()); } }
/** * Used for gaining compatibility with java.util.concurrent when a {@link Delayed} object is * needed. * * @param scheduler Scheduler to submit task to * @param task Task to be submitted * @param priority Priority for task to be submitted at * @param initialDelay initial delay for task to execute * @param periodInMillis recurring delay for task to execute * @return Delayed implementation which corresponds to executed task */ public static Delayed doScheduleAtFixedRateAndGetDelayed(SingleThreadScheduler scheduler, Runnable task, TaskPriority priority, long initialDelay, long periodInMillis) { NoThreadScheduler nts = scheduler.getRunningScheduler(); QueueSet queueSet = nts.queueManager.getQueueSet(priority); NoThreadRecurringRateTaskWrapper rt = nts.new NoThreadRecurringRateTaskWrapper(task, queueSet, Clock.accurateForwardProgressingMillis() + initialDelay, periodInMillis); queueSet.addScheduled(rt); return new DelayedTaskWrapper(rt); }
/** * Used for gaining compatibility with java.util.concurrent when a {@link Delayed} object is * needed. * * @param scheduler Scheduler to submit task to * @param task Task to be submitted * @param priority Priority for task to be submitted at * @param initialDelay initial delay for task to execute * @param periodInMillis recurring delay for task to execute * @return Delayed implementation which corresponds to executed task */ public static Delayed doScheduleAtFixedRateAndGetDelayed(SingleThreadScheduler scheduler, Runnable task, TaskPriority priority, long initialDelay, long periodInMillis) { NoThreadScheduler nts = scheduler.getRunningScheduler(); QueueSet queueSet = nts.queueManager.getQueueSet(priority); NoThreadRecurringRateTaskWrapper rt = nts.new NoThreadRecurringRateTaskWrapper(task, queueSet, Clock.accurateForwardProgressingMillis() + initialDelay, periodInMillis); queueSet.addScheduled(rt); return new DelayedTaskWrapper(rt); }
@Test public void getDelayTillNextTaskTest() { assertEquals(Long.MAX_VALUE, scheduler.getDelayTillNextTask()); // schedule in the future scheduler.schedule(DoNothingRunnable.instance(), 1000 * 15); // still should have nothing ready to run assertTrue(scheduler.getDelayTillNextTask() > 0); scheduler.execute(DoNothingRunnable.instance()); // should now have tasks ready to run assertTrue(scheduler.getDelayTillNextTask() <= 0); scheduler.tick(null); // should no longer have anything to run assertTrue(scheduler.getDelayTillNextTask() > 0); scheduler.queueManager.highPriorityQueueSet .addScheduled(new OneTimeTaskWrapper(DoNothingRunnable.instance(), scheduler.queueManager.highPriorityQueueSet.scheduleQueue, Clock.lastKnownForwardProgressingMillis())); // now should be true with scheduled task which is ready to run assertTrue(scheduler.getDelayTillNextTask() <= 0); }
@Test public void hasTaskReadyToRunTest() { assertFalse(scheduler.hasTaskReadyToRun()); // schedule in the future scheduler.schedule(DoNothingRunnable.instance(), 1000 * 15); // still should have nothing ready to run assertFalse(scheduler.hasTaskReadyToRun()); scheduler.execute(DoNothingRunnable.instance()); // should now have tasks ready to run assertTrue(scheduler.hasTaskReadyToRun()); scheduler.tick(null); // should no longer have anything to run assertFalse(scheduler.hasTaskReadyToRun()); scheduler.queueManager.highPriorityQueueSet .addScheduled(new OneTimeTaskWrapper(DoNothingRunnable.instance(), scheduler.queueManager.highPriorityQueueSet.scheduleQueue, Clock.lastKnownForwardProgressingMillis())); // now should be true with scheduled task which is ready to run assertTrue(scheduler.hasTaskReadyToRun()); }
@Test public void getNextReadyTaskScheduledAheadOfExecuteTest() { TaskWrapper scheduleTask = new OneTimeTaskWrapper(DoNothingRunnable.instance(), queueManager.highPriorityQueueSet.scheduleQueue, Clock.accurateForwardProgressingMillis()); queueManager.highPriorityQueueSet.addScheduled(scheduleTask); TestUtils.blockTillClockAdvances(); OneTimeTaskWrapper executeTask = new OneTimeTaskWrapper(DoNothingRunnable.instance(), queueManager.highPriorityQueueSet.executeQueue, Clock.lastKnownForwardProgressingMillis()); queueManager.highPriorityQueueSet.addExecute(executeTask); assertTrue(scheduleTask == queueManager.getNextTask()); assertTrue(scheduleTask == queueManager.getNextTask()); // schedule task has not been removed yet // this should remove the schedule task so we can get the execute task assertTrue(scheduleTask.canExecute(executeTask.getExecuteReference())); assertTrue(executeTask == queueManager.getNextTask()); }
@Test public void getNextReadyTaskExecuteAheadOfScheduledTest() { OneTimeTaskWrapper executeTask = new OneTimeTaskWrapper(DoNothingRunnable.instance(), queueManager.highPriorityQueueSet.executeQueue, Clock.accurateForwardProgressingMillis()); queueManager.highPriorityQueueSet.addExecute(executeTask); TestUtils.blockTillClockAdvances(); TaskWrapper scheduleTask = new OneTimeTaskWrapper(DoNothingRunnable.instance(), queueManager.highPriorityQueueSet.scheduleQueue, Clock.lastKnownForwardProgressingMillis()); queueManager.highPriorityQueueSet.addScheduled(scheduleTask); assertTrue(executeTask == queueManager.getNextTask()); assertTrue(executeTask == queueManager.getNextTask()); // execute task has not been removed yet // this should remove the execute task so we can get the scheduled task assertTrue(executeTask.canExecute(executeTask.getExecuteReference())); assertTrue(scheduleTask == queueManager.getNextTask()); }
@Override public void scheduleAtFixedRate(Runnable task, long initialDelay, long period, TaskPriority priority) { ArgumentVerifier.assertNotNull(task, "task"); ArgumentVerifier.assertNotNegative(initialDelay, "initialDelay"); ArgumentVerifier.assertGreaterThanZero(period, "period"); if (priority == null) { priority = defaultPriority; } QueueSet queueSet = queueManager.getQueueSet(priority); NoThreadRecurringRateTaskWrapper taskWrapper = new NoThreadRecurringRateTaskWrapper(task, queueSet, nowInMillis(true) + initialDelay, period); queueSet.addScheduled(taskWrapper); }
@Override public void scheduleAtFixedRate(Runnable task, long initialDelay, long period, TaskPriority priority) { ArgumentVerifier.assertNotNull(task, "task"); ArgumentVerifier.assertNotNegative(initialDelay, "initialDelay"); ArgumentVerifier.assertGreaterThanZero(period, "period"); if (priority == null) { priority = defaultPriority; } QueueSet queueSet = queueManager.getQueueSet(priority); NoThreadRecurringRateTaskWrapper taskWrapper = new NoThreadRecurringRateTaskWrapper(task, queueSet, nowInMillis(true) + initialDelay, period); queueSet.addScheduled(taskWrapper); }
@Override public void scheduleWithFixedDelay(Runnable task, long initialDelay, long recurringDelay, TaskPriority priority) { ArgumentVerifier.assertNotNull(task, "task"); ArgumentVerifier.assertNotNegative(initialDelay, "initialDelay"); ArgumentVerifier.assertNotNegative(recurringDelay, "recurringDelay"); if (priority == null) { priority = defaultPriority; } QueueSet queueSet = queueManager.getQueueSet(priority); NoThreadRecurringDelayTaskWrapper taskWrapper = new NoThreadRecurringDelayTaskWrapper(task, queueSet, nowInMillis(true) + initialDelay, recurringDelay); queueSet.addScheduled(taskWrapper); }
@Override public void scheduleWithFixedDelay(Runnable task, long initialDelay, long recurringDelay, TaskPriority priority) { ArgumentVerifier.assertNotNull(task, "task"); ArgumentVerifier.assertNotNegative(initialDelay, "initialDelay"); ArgumentVerifier.assertNotNegative(recurringDelay, "recurringDelay"); if (priority == null) { priority = defaultPriority; } QueueSet queueSet = queueManager.getQueueSet(priority); NoThreadRecurringDelayTaskWrapper taskWrapper = new NoThreadRecurringDelayTaskWrapper(task, queueSet, nowInMillis(true) + initialDelay, recurringDelay); queueSet.addScheduled(taskWrapper); }
@Test public void getNextReadyTaskHighPriorityDelayedTest() { TaskWrapper scheduleTask = new OneTimeTaskWrapper(DoNothingRunnable.instance(), queueManager.highPriorityQueueSet.scheduleQueue, Clock.accurateForwardProgressingMillis() + 1000); queueManager.highPriorityQueueSet.addScheduled(scheduleTask); TestUtils.blockTillClockAdvances(); OneTimeTaskWrapper executeTask = new OneTimeTaskWrapper(DoNothingRunnable.instance(), queueManager.lowPriorityQueueSet.executeQueue, Clock.lastKnownForwardProgressingMillis()); queueManager.lowPriorityQueueSet.addExecute(executeTask); assertTrue(executeTask == queueManager.getNextTask()); }
@Override protected OneTimeTaskWrapper doSchedule(Runnable task, long delayInMillis, TaskPriority priority) { QueueSet queueSet = queueManager.getQueueSet(priority); OneTimeTaskWrapper result; if (delayInMillis == 0) { queueSet.addExecute((result = new NoThreadOneTimeTaskWrapper(task, queueSet.executeQueue, nowInMillis(false)))); } else { queueSet.addScheduled((result = new NoThreadOneTimeTaskWrapper(task, queueSet.scheduleQueue, nowInMillis(true) + delayInMillis))); } return result; }
@Override protected OneTimeTaskWrapper doSchedule(Runnable task, long delayInMillis, TaskPriority priority) { QueueSet queueSet = queueManager.getQueueSet(priority); OneTimeTaskWrapper result; if (delayInMillis == 0) { queueSet.addExecute((result = new NoThreadOneTimeTaskWrapper(task, queueSet.executeQueue, nowInMillis(false)))); } else { queueSet.addScheduled((result = new NoThreadOneTimeTaskWrapper(task, queueSet.scheduleQueue, nowInMillis(true) + delayInMillis))); } return result; }
@Test public void getNextReadyTaskLowPriorityReadyFirstTest() { TaskWrapper highTask = new OneTimeTaskWrapper(DoNothingRunnable.instance(), queueManager.highPriorityQueueSet.scheduleQueue, Clock.accurateForwardProgressingMillis() + (DELAY_TIME * 10)); TaskWrapper lowTask = new OneTimeTaskWrapper(DoNothingRunnable.instance(), queueManager.lowPriorityQueueSet.scheduleQueue, Clock.lastKnownForwardProgressingMillis() + DELAY_TIME); queueManager.highPriorityQueueSet.addScheduled(highTask); queueManager.lowPriorityQueueSet.addScheduled(lowTask); assertTrue(lowTask == queueManager.getNextTask()); }
@Test public void getNextReadyTaskHighPriorityReadyFirstTest() { TaskWrapper highTask = new OneTimeTaskWrapper(DoNothingRunnable.instance(), queueManager.highPriorityQueueSet.scheduleQueue, Clock.accurateForwardProgressingMillis() + DELAY_TIME); TaskWrapper lowTask = new OneTimeTaskWrapper(DoNothingRunnable.instance(), queueManager.lowPriorityQueueSet.scheduleQueue, Clock.lastKnownForwardProgressingMillis() + (DELAY_TIME * 10)); queueManager.highPriorityQueueSet.addScheduled(highTask); queueManager.lowPriorityQueueSet.addScheduled(lowTask); assertTrue(highTask == queueManager.getNextTask()); }
private void getNextReadyTaskScheduledTest(QueueSet queueSet) { TaskWrapper task = new OneTimeTaskWrapper(DoNothingRunnable.instance(), queueSet.scheduleQueue, Clock.lastKnownForwardProgressingMillis()); queueSet.addScheduled(task); assertTrue(task == queueManager.getNextTask()); }
@Test public void addScheduledTest() { TaskWrapper task = new OneTimeTaskWrapper(DoNothingRunnable.instance(), null, Clock.lastKnownForwardProgressingMillis() + 10); queueSet.addScheduled(task); assertEquals(0, queueSet.executeQueue.size()); assertEquals(1, queueSet.scheduleQueue.size()); }