Starts the continuous scanning process for this document after a given interval.
198157
function() {
      if (this.scanner) {
        this.parent.clearTimeout(this.documentScan);
        this.documentScan = this.parent.setTimeout(this.scanner, this.options.continuousScanning);
      }
    }
633050
@Override
	public void resumeScan() {
		lock.lock();
		try {
			if (State.PAUSED.equals(state)) {
				spiderThread.resumeScan();
				state = State.RUNNING;
				SpiderEventPublisher.publishScanEvent(
						ScanEventPublisher.SCAN_RESUMED_EVENT, this.scanId);
			}
		} finally {
			lock.unlock();
		}
	}
467955
def start(self):
        
        self.running = True
        self.status = 'RUNNING'
        self.mylog.record_process('agent', self.name + ' - starting')
1031077
def run(self):
        
        self._capture_signals()
        self._start_monitor()
        try:
            while True:
                if not self._run_worker():
                    self._wait_for_changes()
                time.sleep(self.reload_interval)
        except KeyboardInterrupt:
            pass
        finally:
            self._stop_monitor()
            self._restore_signals()
        sys.exit(1)
1236812
public void start() {

		if( this.timer == null ) {
			this.logger.fine( "Agent Monitoring is being started." );

			this.timer = new ScheduledThreadPoolExecutor( 1 );
			this.timer.scheduleWithFixedDelay(
					new MonitoringRunnable( this.agentInterface, this.handlers ),
					0, Constants.PROBES_POLLING_PERIOD, TimeUnit.MILLISECONDS );
		}
	}
854634
def start(self):
        """"""
        self.agent.submit(self._start())
        self.is_running = True
987304
public synchronized void start() {
        if (monitorActive) {
            return;
        }
        lastTime.set(milliSecondFromNano());
        long localCheckInterval = checkInterval.get();
        // if executor is null, it means it is piloted by a GlobalChannelTrafficCounter, so no executor
        if (localCheckInterval > 0 && executor != null) {
            monitorActive = true;
            monitor = new TrafficMonitoringTask();
            scheduledFuture =
                executor.schedule(monitor, localCheckInterval, TimeUnit.MILLISECONDS);
        }
    }
107028
def run(self):
        """"""
        while True:
            self.running = True
            workunit = self._workq.get()
            if is_sentinel(workunit):
                # Got sentinel
                break

            # Run the job / sequence
            workunit.process()
        self.running = False
339494
def run(self):
        """"""

        self.viewing = True
        while self.viewing and self._lock.acquire():
            try:
                line = self._readline()
            except:
                pass
            else:
                logger.info(line)
            self._lock.release()
            time.sleep(0)
1251200
def run(self):
        """"""
        while not self._finished.isSet():
            self._func(self._reference)
            self._finished.wait(self._func._interval / 1000.0)
1270367
public void run() {
		
		while( running ) {
			
			long interval_end = System.currentTimeMillis() + interval;
			
			while( interval_end > System.currentTimeMillis() ) {
				
				Thread.yield();
				
			}
			
			fireIntervalElapsed();
			
		}
		
		running = false;
		
	}
1008544
public final void start() {
    if (this.started) {
      log.warn(String.format("Reporter %s has already been started.", this.name));
      return;
    }
    try {
      startImpl();
      this.started = true;
    } catch (Exception exception) {
      log.warn(String.format("Reporter %s did not start correctly.", this.name), exception);
    }
  }
924202
def start_heartbeat(self):
        """"""
        self.stop_heartbeat()

        self._heartbeat_timer = periodic.Callback(self._heartbeat,
                                                  self._heartbeat_interval,
                                                  self.server.io_loop)
        self._heartbeat_timer.start()
186164
final void continuouslyRestart(long interval) throws IOException, InterruptedException {
        LOGGER.entering(interval);

        while (true) {
            if (!isInitialized()) {
                FileDownloader.checkForDownloads(getType(), getLauncherOptions()
                        .isFileDownloadCheckTimeStampOnInvocation(), getLauncherOptions()
                        .isFileDownloadCleanupOnInvocation());
            }

            startProcess(false);

            while (!handler.hasResult()) {
                LOGGER.fine("Child process still running. Going back to sleep.");
                Thread.sleep(interval);
            }

            if (handler.hasResult()) {
                ExecuteException e = handler.getException();
                if (e != null) {
                    LOGGER.log(Level.SEVERE, handler.getException().getMessage(), handler.getException());
                }
            }
            LOGGER.info("Child process quit. Restarting it.");
            setInitialized(false);
        }
    }
466504
def run(self):
        
        self.stop = False
        while not self.stop:
            self.tracker.create_snapshot()
            sleep(self.interval)
1211990
def start(self):
        """"""
        self._lc = LoopingCall(self._download)
        # Run immediately, and then every 30 seconds:
        self._lc.start(30, now=True)
880451
def run(self):
        """"""
        while True:
            try:
                self.perform_iteration()
            except Exception:
                traceback.print_exc()
                pass

            time.sleep(ray_constants.REPORTER_UPDATE_INTERVAL_MS / 1000)