Schedules a polling of this project.
@see SCMTriggerItem#schedulePolling
342014
public boolean schedulePolling() {
        if(isDisabled())    return false;
        SCMTrigger scmt = getTrigger(SCMTrigger.class);
        if(scmt==null)      return false;
        scmt.run();
        return true;
    }
90092
def _schedule(self):
        ''''''
        if self._running:
            _logger.debug('')
            self._call_later_handle = self._event_loop.call_later(
                self._timeout, self._check)
855207
private void processScheduleOptions()
   {
      List<Row> rows = getRows("schedoptions", "proj_id", m_projectID);
      if (rows.isEmpty() == false)
      {
         Row row = rows.get(0);
         Map<String, Object> customProperties = new HashMap<String, Object>();
         customProperties.put("LagCalendar", row.getString("sched_calendar_on_relationship_lag"));
         customProperties.put("RetainedLogic", Boolean.valueOf(row.getBoolean("sched_retained_logic")));
         customProperties.put("ProgressOverride", Boolean.valueOf(row.getBoolean("sched_progress_override")));
         customProperties.put("IgnoreOtherProjectRelationships", row.getString("sched_outer_depend_type"));
         customProperties.put("StartToStartLagCalculationType", Boolean.valueOf(row.getBoolean("sched_lag_early_start_flag")));
         m_reader.getProject().getProjectProperties().setCustomProperties(customProperties);
      }
   }
464838
private void scheduleUpdate() {
		if (!isVisible()) {
			return;
		}
		
		SwingUtilities.invokeLater(new Runnable() {
			public void run() {
				try {
					container.gameLoop();
				} catch (SlickException e) {
					e.printStackTrace();
				}
				container.checkDimensions();
				scheduleUpdate();
			}
		});
	}
567486
public void apply() {
        Scheduler.get().scheduleDeferred(() -> {
            if (widget != null) {
                $(widget.getElement()).pushpin(options);
            } else {
                GWT.log("Please set your widget before applying the pushpin", new IllegalStateException());
            }
        });
    }
573729
@Override
    public void run() {
        Date actualExecutionTime = new Date();
        super.run();
        Date completionTime = new Date();
        synchronized (this.triggerContextMonitor) {
            this.triggerContext.update(this.scheduledExecutionTime, actualExecutionTime, completionTime);
            if (!this.currentFuture.isCancelled()) {
                schedule();
            }
        }
    }
713495
@Override
  protected void startUp() {
    log.info("Starting the " + getClass().getSimpleName());
    log.info("Polling git with interval {} ", this.pollingInterval);

    // Schedule the job config fetch task
    this.scheduledExecutor.scheduleAtFixedRate(new Runnable() {
      @Override
      public void run() {
        try {
          if (shouldPollGit()) {
            processGitConfigChanges();
          }
        } catch (GitAPIException | IOException e) {
          log.error("Failed to process git config changes", e);
          // next run will try again since errors could be intermittent
        }
      }
    }, 0, this.pollingInterval, TimeUnit.SECONDS);
  }
850412
private void schedule(TaskScheduler scheduler) {
        scheduledFuture = scheduler.scheduleAtFixedRate(
                createTask(), (int)delayTime, (int)period, TimeUnit.MILLISECONDS);
    }
158715
@Override
    public void run() {
        try {
            ScheduledEventQueue queue = ScheduledEventQueue.getSingleton();
            int batch_size = PropertyManager.getIntegerProperty(PropertyNames.SCHEDULED_EVENTS_BATCH_SIZE, 1000);
            int count = 0;
            Date now = new Date(DatabaseAccess.getCurrentTime());
            logger.log(LogLevel.TRACE, "Processing scheduled events at: " + now);
            ScheduledEvent event = queue.getNextReadyEvent(now);
            while (event!=null && count < batch_size) {
                count++;
                queue.processEvent(event, now);
                event = queue.getNextReadyEvent(now);
            }
        }
        catch (Throwable t) {
            logger.severeException(t.getMessage(), t);
        }
    }
275755
public void scheduleRecurring(Runnable runnable, Date firstTime, long period)
   {
	timer.scheduleAtFixedRate(toTimerTask(runnable), firstTime, period);
	
   }
218364
@Override
    public ScheduledFuture<?> schedule(Topic topic, long delay, TimeUnit unit) {
        return schedule(topic, null, delay, unit);
    }
528031
@Override
    public void run() {
        try {
            if (this.isDone()) {
                return;
            }
            ExpeditedFutureTask<V> futureTask = new ExpeditedFutureTask<V>(this.m_callable);
            this.m_defaultFuture = futureTask;
            this.m_executor.execute(futureTask);
            this.m_scheduledExecutorQueue.remove(this);
        } catch (Exception e) {
            this.m_pendingException = new RuntimeException(e);
            return;
        } finally {
            // Let blocked ScheduleFuture methods thru now.
            this.m_coordinationLatch.countDown();
        }
    }
363931
@Override
	public void run (long timeToRun) {
		// Increment the frame number
		frame++;

		// Clear the list of tasks to run
		runList.size = 0;

		// Go through each task
		for (int i = 0; i < schedulableRecords.size; i++) {
			SchedulableRecord record = schedulableRecords.get(i);
			// If it is due, schedule it
			if ((frame + record.phase) % record.frequency == 0) runList.add(record);
		}

		// Keep track of the current time
		long lastTime = TimeUtils.nanoTime();

		// Find the number of tasks we need to run
		int numToRun = runList.size;

		// Go through the tasks to run
		for (int i = 0; i < numToRun; i++) {
			// Find the available time
			long currentTime = TimeUtils.nanoTime();
			timeToRun -= currentTime - lastTime;
			long availableTime = timeToRun / (numToRun - i);

			// Run the schedulable object
			runList.get(i).schedulable.run(availableTime);

			// Store the current time
			lastTime = currentTime;
		}
	}
1296987
@Override
    public ScheduledFuture<?> schedulePriorityWork(Runnable work,
            long initialDelay,
            long delay,
            TimeUnit unit) {
        if (delay > 0) {
            return m_periodicPriorityWorkThread.scheduleWithFixedDelay(work,
                    initialDelay, delay,
                    unit);
        } else {
            return m_periodicPriorityWorkThread.schedule(work, initialDelay, unit);
        }
    }
297689
public static void scheduleJob(String sessionId, String azkabanProjectId,
      AzkabanProjectConfig azkabanProjectConfig)
      throws IOException {
    log.info("Scheduling Azkaban project: " + azkabanProjectConfig.getAzkabanProjectName());
    AzkabanAjaxAPIClient.scheduleAzkabanProject(sessionId, azkabanProjectId, azkabanProjectConfig);
  }
695964
private void scheduleReload() {

        if (!isReloadScheduled() && (OpenCms.getRunLevel() > OpenCms.RUNLEVEL_1_CORE_OBJECT)) {
            // only schedule a reload if the system is not going down already
            m_threadCount++;
            Thread thread = new Thread("Bundle reload Thread " + m_threadCount) {

                @Override
                public void run() {

                    setReloadScheduled(true);
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        // ignore
                    }
                    if (isReloadScheduled()) {
                        reload(false);
                    }
                    setReloadScheduled(false);
                }
            };
            thread.start();
        }
    }
290310
public void addPoller(PollRunnable task, long delay, TimeUnit timeUnit) {
    ScheduledExecutorService service = executor.get();
    if (service != null) {
      service.scheduleWithFixedDelay(task, 0, delay, timeUnit);
    } else {
      throw new IllegalStateException(
          "you must start the scheduler before tasks can be submitted");
    }
  }