'tick' the scheduler.
You should NEVER call this method, unless you know what you are doing.
161008
function (dt) {
        var i, len, x
        if (this.timeScale != 1.0) {
            dt *= this.timeScale
        }

        var entry
        for (i = 0, len = this.updatesNeg.length; i < len; i++) {
            entry = this.updatesNeg[i]
            if (entry && !entry.paused) {
                entry.target.update(dt)
            }
        }


        for (i = 0, len = this.updates0.length; i < len; i++) {
            entry = this.updates0[i]
            if (entry && !entry.paused) {
                entry.target.update(dt)
            }
        }

        for (i = 0, len = this.updatesPos.length; i < len; i++) {
            entry = this.updatesPos[i]
            if (entry && !entry.paused) {
                entry.target.update(dt)
            }
        }

        for (x in this.hashForMethods) {
            if (this.hashForMethods.hasOwnProperty(x)) {
                entry = this.hashForMethods[x]

                if (entry) {
                    for (i = 0, len = entry.timers.length; i < len; i++) {
                        var timer = entry.timers[i]
                        if (timer) {
                            timer.update(dt)
                        }
                    }
                }
            }
        }

    }
708055
private void unschedule() {
        synchronized (mutex) {
            if (pendingFuture != null && !pendingFuture.isDone() && !pendingFuture.isCancelled()) {
                Log.v(Log.TAG_BATCHER, "%s: cancelling the pending future ...", this);
                pendingFuture.cancel(false);
            }
            scheduled = false;
        }
    }
845225
public void tick() throws InterruptedException {
    try (LockResource r = new LockResource(mLock)) {
      HeartbeatScheduler.addTimer(this);
      // Wait in a loop to handle spurious wakeups
      while (!mScheduled) {
        mTickCondition.await();
      }

      mScheduled = false;
    }
  }
319674
def handle_schedule(self):
        '''
        
        '''
        try:
            self.schedule.eval()
            # Check if scheduler requires lower loop interval than
            # the loop_interval setting
            if self.schedule.loop_interval < self.loop_interval:
                self.loop_interval = self.schedule.loop_interval
        except Exception as exc:
            log.error('Exception %s occurred in scheduled job', exc)
243160
def tick(tick = gettime)
      Sidetiq.workers.each do |worker|
        Sidetiq.handler.dispatch(worker, tick)
      end
    end
634680
def cancel(self, job):
        
        if isinstance(job, self.job_class):
            self.connection.zrem(self.scheduled_jobs_key, job.id)
        else:
            self.connection.zrem(self.scheduled_jobs_key, job)
1018162
def __cancel_timer(self):
        
        if self.__timer is not None:
            self.__timer.cancel()
            self.__unbind_call(True)

        self.__timer_args = None
        self.__timer = None
52257
final void rescheduleIfNeeded() {
		if (executeEvery > 0 && !TaskScheduler.stopping) {
			synchronized (this) {
				status = Task.STATUS_NOT_STARTED;
				executeIn(executeEvery);
			}
			TaskScheduler.schedule(this);
		} else if (nextExecution > 0 && !TaskScheduler.stopping) {
			synchronized (this) {
				this.status = Task.STATUS_NOT_STARTED;
			}
			TaskScheduler.schedule(this);
		}
	}
60083
synchronized void unschedule(String scheduledJobId) {
    try {
      quartzScheduler.deleteJob(new JobKey(scheduledJobId, SCHEDULED_JOB_GROUP));
    } catch (SchedulerException e) {
      String message = format("Error deleting ScheduledJob ''{0}''", scheduledJobId);
      LOG.error(message, e);
      throw new ScheduledJobException(message, e);
    }
  }
225662
private synchronized void reschedule(long millis) {
        currentFut = null;  // Remove current future.

        if (!closed) {
            SCHEDULER.schedule(this::refresh, millis, TimeUnit.MILLISECONDS);
        } else {
            try {
                underlying.close();
            } catch (Exception ex) {
                LOG.log(Level.WARNING, "failed to close resolver " + underlying.configString(), ex);
            }
        }
    }
48322
def _call_when_changed(self, ticks, state):
        
        method = self._when_changed()
        if method is None:
            self.when_changed = None
        else:
            method(ticks, state)
758173
function resetTimer() {
              if( cancelTimer ) {
                cancelTimer();
                cancelTimer = null;
              }
              if( start && Date.now() - start > maxWait ) {
                if(!runScheduledForNextTick){
                  runScheduledForNextTick = true;
                  utils.compile(runNow);
                }
              }
              else {
                if( !start ) { start = Date.now(); }
                cancelTimer = utils.wait(runNow, wait);
              }
            }
402554
private void scheduleAlarm() {
    if (wasCalledViaHTTP || retry >= maxNumberOfRetries) {
      // No alarm necessary anymore.
      LOG.log(Level.INFO,
          "Not scheduling additional alarms after {0} out of max {1} retries. The HTTP handles was called: ",
          new Object[] {retry, maxNumberOfRetries, wasCalledViaHTTP});
      return;
    }

    // Scheduling an alarm will prevent the clock from going idle.
    ++retry;
    clock.scheduleAlarm(alarmInterval, alarmHandler);
  }
478064
public void tick() {
        final long count = uncounted.sumThenReset();
        final double instantRate = count / interval;
        if (initialized) {
            rate += (alpha * (instantRate - rate));
        } else {
            rate = instantRate;
            initialized = true;
        }
    }
1172957
void tick(long index, long timestamp) {
    // Only create an iterator if there are actually tasks scheduled.
    if (!scheduledTasks.isEmpty()) {

      // Iterate through scheduled tasks until we reach a task that has not met its scheduled time.
      // The tasks list is sorted by time on insertion.
      Iterator<ServerScheduledTask> iterator = scheduledTasks.iterator();
      while (iterator.hasNext()) {
        ServerScheduledTask task = iterator.next();
        if (task.complete(timestamp)) {
          context.update(index, Instant.ofEpochMilli(task.time), ServerStateMachineContext.Type.COMMAND);
          task.execute();
          complete.add(task);
          iterator.remove();
        } else {
          break;
        }
      }

      // Iterate through tasks that were completed and reschedule them.
      for (ServerScheduledTask task : complete) {
        task.reschedule();
      }
      complete.clear();
    }
  }
181608
void stop() {
        ScheduledFuture<?> future = this.rollupFuture.getAndSet(null);
        if (future != null && !future.isDone() && !future.isCancelled()) {
            // Stop running the scheduled job, letting any currently running rollup finish ...
            future.cancel(false);
        }
    }
555267
public void unscheduleTask() {
    if (unschedule.compareAndSet(false, true)) {
      scheduledFuture.cancel(false);
      scheduledFuture = null;
    }

  }