Starts scheduler.
160589
public void start() {
        if (this.isActive)
            return;

        if (clock == null) {
            throw new IllegalStateException("Clock is not set");
        }

        this.isActive = true;

        logger.info("Starting ");

        cpuThread.activate();

        logger.info("Started ");
    }
685189
@PostConstruct
  public void setupScheduler() {
    for(SchedulerTask task : tasks) {
      if(task.getDelay() > 0 && task.getInterval() > 0) {
        executor.scheduleWithFixedDelay(task.getTask(), task.getDelay(), task.getInterval(), task.getTimeUnit());
      } else if(task.isImmediate() && task.getInterval() > 0) {
        executor.scheduleWithFixedDelay(task.getTask(), 0l, task.getInterval(), task.getTimeUnit());
      } else if(task.getDelay() > 0) {
        executor.schedule(task.getTask(), task.getDelay(), task.getTimeUnit());
      } else {
        executor.execute(task.getTask());
      }
    }
  }
787714
def _start(self):
        """"""
        if len(self._queue) == 1:
            thread = self._queue.popleft()
            thread.start()
            self._timer.start()
710531
public void start() {
        CircuitManager cm = this.stack.getCircuitManager();
        long[] channelIDs = cm.getChannelIDs();
        this.cic2Circuit.clear();

        for (long channelID : channelIDs) {
            Circuit c = new Circuit(cm.getCIC(channelID), cm.getDPC(channelID), this, scheduler);
            cic2Circuit.put(channelID, c);
        }
    }
584257
private void startLogScheduler() {
    this.logScheduler.scheduleAtFixedRate(
        new Runnable() {
          @Override
          public void run() {
            CLRBufferedLogHandler.this.logAll();
          }
        }, 0, LOG_SCHEDULE_PERIOD, TimeUnit.SECONDS);
  }
458670
def main():
    
    args = parser.parse_args()

    scheduler = Scheduler()

    print 'Start %s' % scheduler.scheduler_id
    scheduler.interval = args.interval
    if args.keepalive:
        scheduler.run(once=True)
        keepalive = Job('simplescheduler.keepalive',
                        args=[0,
                              scheduler.get_running_scheduler_id(),
                              args.interval * 2])
        scheduler.schedule(keepalive, long(time.time() * 1000000))
    scheduler._run()
81968
public void start() {
		if ((schedulerThread == null || !schedulerThread.isAlive()) && interval > 0) {
			schedulerThread = new Thread(this);
			//act as internal request to be able to bind internal process
//			Request currentRequest = application.getCurrentRequest();
//			currentRequest.startRepresentingRequest(initialRequest);
//			application.bindInternalProcess(schedulerThread, "scheduler");
//			currentRequest.stopRepresentingRequest();
			schedulerThread.start();
			System.out.println(new LogEntry("scheduler thread started..."));
		}
	}
1249313
def start(inqueue, outqueue=None):
    """"""
    conf.init(), db.init(conf.DbPath)
    Listener(inqueue, outqueue).run()
57051
public void start() {
		synchronized (_lock) {
			// Stop previously set timer
			_timer.purge();

			// Set a new timer
			TimerTask task = new TimerTask() {
				@Override
				public void run() {
					try {
						_task.notify("pip-commons-timer", new Parameters());
					} catch (Exception ex) {
						// Ignore or better log!
					}
				}
			};
			_timer.scheduleAtFixedRate(task, _delay, _interval);

			// Set started flag
			_started = true;
		}
	}
647600
public function start() {
        if ($this->watcher !== null) {
            return;
        }

        $this->watcher = Loop::repeat($this->checkInterval, function () {
            // Use double defer to calculate complete tick time
            // instead of timer → defer time.
            Loop::unreference(Loop::defer($this->check));
        });

        Loop::unreference($this->watcher);
    }
338632
@LifecycleStart
  public void start()
  {
    giant.lock();

    try {
      Preconditions.checkState(!active, "queue must be stopped");
      active = true;
      syncFromStorage();
      managerExec.submit(
          new Runnable()
          {
            @Override
            public void run()
            {
              while (true) {
                try {
                  manage();
                  break;
                }
                catch (InterruptedException e) {
                  log.info("Interrupted, exiting!");
                  break;
                }
                catch (Exception e) {
                  final long restartDelay = config.getRestartDelay().getMillis();
                  log.makeAlert(e, "Failed to manage").addData("restartDelay", restartDelay).emit();
                  try {
                    Thread.sleep(restartDelay);
                  }
                  catch (InterruptedException e2) {
                    log.info("Interrupted, exiting!");
                    break;
                  }
                }
              }
            }
          }
      );
      ScheduledExecutors.scheduleAtFixedRate(
          storageSyncExec,
          config.getStorageSyncRate(),
          new Callable<ScheduledExecutors.Signal>()
          {
            @Override
            public ScheduledExecutors.Signal call()
            {
              try {
                syncFromStorage();
              }
              catch (Exception e) {
                if (active) {
                  log.makeAlert(e, "Failed to sync with storage").emit();
                }
              }
              if (active) {
                return ScheduledExecutors.Signal.REPEAT;
              } else {
                return ScheduledExecutors.Signal.STOP;
              }
            }
          }
      );
      managementMayBeNecessary.signalAll();
    }
    finally {
      giant.unlock();
    }
  }
793187
@Override
    public synchronized void start() {
        if (monitorActive) {
            return;
        }
        lastTime.set(milliSecondFromNano());
        long localCheckInterval = checkInterval.get();
        if (localCheckInterval > 0) {
            monitorActive = true;
            monitor = new MixedTrafficMonitoringTask((GlobalChannelTrafficShapingHandler) trafficShapingHandler, this);
            scheduledFuture =
                executor.schedule(monitor, localCheckInterval, TimeUnit.MILLISECONDS);
        }
    }
436608
def startService(self):
        
        super(_SiteScheduler, self).startService()
        self._transientSchedule(self.now(), self.now())
475144
public void start() {
        logger.info("Started AWSCloudTrailProcessingLibrary.");
        validateBeforeStart();
        scheduledThreadPool.scheduleAtFixedRate(new ScheduledJob(readerFactory), 0L, EXECUTION_DELAY, TimeUnit.MICROSECONDS);
    }
810817
def start(self):
        """"""
        zones = [{"id": data[0], "duration": data[1], "sortOrder": count}
                 for (count, data) in enumerate(self._zones, 1)]
        self._api.startMultiple(zones)
241213
def start(self):
		
		if self._thread_running.is_set():
			raise RuntimeError('the JobManager has already been started')
		self._thread.start()
		self._thread_running.wait()
		return
931424
protected function startScheduler()
    {
        $this->now = new \DateTime('now', new \DateTimeZone('UTC'));

        $periodStart = clone $this->now;
        $periodStart->modify('-'.$this->interval.' minutes');

        $scheduler = new Scheduler();
        $scheduler->setStatus(Scheduler::STATUS_RUNNING);
        $scheduler->setExecutionStart($this->now);
        $scheduler->setPeriodStart($periodStart);
        $scheduler->setPeriodEnd($this->now);
        $scheduler->setPeriodInterval($this->interval);

        $this->em->persist($scheduler);
        $this->em->flush();

        return $scheduler;
    }