Starts scheduler.
356587
public void start() {
    	if(this.isActive)
    		return;
    	
        if (clock == null) {
            throw new IllegalStateException("Clock is not set");
        }

        this.isActive = true;
        
        logger.info("Starting ");
        
        coreThread.activate();
        criticalThread.activate();
        for(int i=0;i<workerThreads.length;i++)
        	workerThreads[i].activate();
        
        for(int i=0;i<criticalWorkerThreads.length;i++)
        	criticalWorkerThreads[i].activate();        
        
        logger.info("Started ");
    }
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
13998
public void start() {
    if (isActive) {
      return;
    }

    log.info("Starting up the default async job executor [{}].", getClass().getName());
    
    if (timerJobRunnable == null) {
      timerJobRunnable = new AcquireTimerJobsRunnable(this, processEngineConfiguration.getJobManager());
    }
    
    if (resetExpiredJobsRunnable == null) {
      resetExpiredJobsRunnable = new ResetExpiredJobsRunnable(this);
    }
    
    if (!isMessageQueueMode && asyncJobsDueRunnable == null) {
      asyncJobsDueRunnable = new AcquireAsyncJobsDueRunnable(this);
    }
    
    if (!isMessageQueueMode) {
      initAsyncJobExecutionThreadPool();
      startJobAcquisitionThread();
    }
    
    startTimerAcquisitionThread();
    startResetExpiredJobsThread();

    isActive = true;

    executeTemporaryJobs();
  }
823125
@Validate
    public void start() {
        metrics.register("executors", new MetricSet() {
            @Override
            public Map<String, Metric> getMetrics() {
                return ImmutableMap.<String, Metric>of(
                        "executors.count", new Gauge<Integer>() {
                            @Override
                            public Integer getValue() {
                                return getExecutors().length;
                            }
                        },
                        "schedulers.count", new Gauge<Integer>() {

                            @Override
                            public Integer getValue() {
                                return getSchedulers().length;
                            }
                        },
                        "hung.count", new Gauge<Integer>() {

                            @Override
                            public Integer getValue() {
                                return getHungTasks();
                            }
                        },
                        "completed.count", new Gauge<Integer>() {

                            @Override
                            public Integer getValue() {
                                return getCompletedTasks();
                            }
                        }
                );
            }
        });

        for (ManagedExecutorService service : executors) {
            metrics.register(service.name(), metricsForExecutor(service));
        }

        for (ManagedExecutorService service : schedulers) {
            metrics.register(service.name(), metricsForExecutor(service));
        }
    }
1088104
void start() {
    /* make sure any currently running dispatchers are stopped */
    stop();

    /* create the download dispatcher and start it. */
    for (int i = 0; i < dispatchers.length; i++) {
      DownloadDispatcher dispatcher = new DownloadDispatcher(downloadQueue, delivery, logger);
      dispatchers[i] = dispatcher;
      dispatcher.start();
    }

    logger.log("Thread pool size: " + dispatchers.length);
  }
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;
    }
415865
private synchronized void start() {
        // only reschedule if monitor is still active (not in the process of being initialized or destroyed
        // don't schedule a task if there are no monitors or the monitorInterval was set to 0
        // don't schedule a task if the framework is stopping
        if (scheduledFuture == null
            && monitorState.get() == MonitorState.ACTIVE.ordinal()
            && !updateMonitors.isEmpty()
            && monitorInterval != 0
            && FrameworkState.isValid()) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                Tr.event(this, tc, "Scan task scheduled");
            }
            scheduledFuture = coreService.getScheduler().scheduleWithFixedDelay(this, monitorInterval, monitorInterval, monitorTimeUnit);
        }
    }
617371
def start(self):
        
        with self._lock:
            if self._running:
                return

            self._stopped = False
            self._running = True
            self._start_idle_timer()
            _logger.debug(u'starting thread of type %s to run the scheduler',
                          _THREAD_CLASS)
            self._thread = create_thread(target=self._schedule_flushes)
            try:
                self._thread.start()
            except Exception:  # pylint: disable=broad-except
                _logger.warn(
                    u'no scheduler thread, scheduler.run() will be invoked by report(...)',
                    exc_info=True)
                self._thread = None
                self._initialize_flushing()
692457
public void start() {
    	if(logger.isDebugEnabled()) {
            logger.debug("start");
        }
        started.set(true);
        if(logger.isDebugEnabled()) {
            logger.debug("Started proxy timer service "+ this);
        }
    }
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());
      }
    }
  }
549864
public function startup()
    {
        $reflector = new ReflectionClass('Resque');
        $this->_resqueLibrary = dirname(dirname($reflector->getFileName()));

        $reflector = new ReflectionClass('ResqueScheduler\ResqueScheduler');
        $this->_resqueSchedulerLibrary = dirname(dirname(dirname($reflector->getFileName())));

        $this->ResqueStatus = new ResqueStatus(Resque::redis());

        $this->_io->styles('success', ['text' => 'green']);
        $this->_io->styles('bold', ['bold' => true]);
    }
165591
protected function startup()
    {
        $this->getProcess()->setTitle('Starting');
        $this->registerSignalHandlers();

        $this->eventDispatcher->dispatch(
            ResqueWorkerEvents::START_UP,
            new WorkerEvent($this)
        );
    }
801769
def start_scheduler(self):
        
        t = InfiniteLoopThread(
            func=self.schedule_next_job,
            thread_name="SCHEDULER",
            wait_between_runs=0.5)
        t.start()
        return t
399385
def start(self, paused=False):
        
        if self.host_name not in self.allowed_hosts and '*' not in self.allowed_hosts:
            LOGGER.debug('Host name %s is not allowed to start the APScheduler. Servers allowed: %s' %
                         (self.host_name, ','.join(self.allowed_hosts)))
            return

        self._scheduler.start(paused=paused)
131307
private function start()
    {
        $timer = $this->getStopwatchInstance();
        $timer->start($this->name, $this->category);
    }
859464
public function start()
    {
        $this->logger->info("crontab start");

        $loop = Factory::create();

        // add periodic timer
        $crontab_timer = $loop->addPeriodicTimer(60, array($this, 'crontabCallback'));

        // recover the sub processes
        $loop->addPeriodicTimer(60, array($this, 'processRecoverCallback'));

        $server = new \Jenner\Crontab\HTTP\Server($loop, $this, $crontab_timer);
        $server->start($this->port);

        $loop->run();
    }
1080276
public void start() {
    int numThreads = Runtime.getRuntime().availableProcessors();
    ThreadFactory factory = ThreadFactories.withName("ServoPollScheduler-%d");
    start(Executors.newScheduledThreadPool(numThreads, factory));
  }