Start the polling task.

@param config snapshot of configuration.
764717
private void startPollingTask(Config config) {
        Future<?> future;
        PollingTask pollingTask = new PollingTask(config);

        future = scheduledExecutor.schedule(pollingTask, config.initialPollDelay, TimeUnit.MILLISECONDS);

        pollingFutureRef.getAndSet(future);
    }
927118
public static function start(&$config)
    {
        $config = array_merge(array(
        
            // default action name
            'default_action' => 'index',
        
            // directories where to find controllers
            'dirs' => array('app/actions', 'app/controllers'),

            // default controller namespaces
            'namespace' => ''
            
        ), $config);
        
        self::$config = &$config;
        Atomik::set('app.executor', 'Atomik\Controller\Plugin::execute');
        Atomik::add('atomik.dirs.includes', array_filter(Atomik::path((array) self::$config['dirs'])));
    }
750373
@Override
    public void start() {
        ConnectionPoolMBeanManager.getInstance().registerMonitor(config.getName(), this);

        String seeds = config.getSeeds();
        if (seeds != null && !seeds.isEmpty()) {
            setHosts(config.getSeedHosts());
        }

        config.getLatencyScoreStrategy().start(new Listener() {
            @Override
            public void onUpdate() {
                rebuildPartitions();
            }

            @Override
            public void onReset() {
                rebuildPartitions();
            }
        });
    }
1088023
public void setConfig(Configuration config) {
		if (config == null) {
			throw new IllegalArgumentException("Parameter config must not be null.");
		}
	    this.config = config;
	    this.loadFrom(config);
	}
637673
public function run($class, $config = [])
    {
        $this->config = $this->config + $config;

        $this->class = __NAMESPACE__ . '\\Task\\' . $class;

        $this->task = new $this->class($this);

        if (!empty($this->config['debug']) && !isset($this->config['tools'])) {
            $this->console->out(
                "<bold><red>DEBUG MODE ENABLED:</red></bold>\n".
                " - <underline>Turn off debug in production</underline>, which will stop this output to the console."
            );
        }

        $this->task->execute();
    }
293041
@Override
    public final void restart() {
        if (DynamicTasks.getTaskQueuingContext() != null) {
            doRestart(ConfigBag.EMPTY);
        } else {
            Task<?> task = Tasks.builder().name("restart").body(new Runnable() {
                public void run() {
                    doRestart(ConfigBag.EMPTY);
                }
            }).build();
            Entities.submit(this, task).getUnchecked();
        }
    }
272015
def start(self):
        """"""
        self._init_topics()
        poll_thread = threading.Thread(target=self._poll_queue)
        poll_thread.start()
1002430
public void start() throws InterruptedException, ExecutionException {
        Future<?> task = es.submit(handlePartitionChange);
        task.get();
    }
487990
public void init(final LynxConfig lynxConfig) {
    ShakeDetector shakeDetector = new ShakeDetector(new ShakeDetector.Listener() {
      @Override public void hearShake() {
        if (isEnabled) {
          openLynxActivity(lynxConfig);
        }
      }
    });
    SensorManager sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
    shakeDetector.start(sensorManager);
  }
542060
void start(Handler<ConnectionOutputBatch> startHandler) {
    connection.doBatchStart(id, args);
    this.startHandler = startHandler;
  }
186669
public synchronized void start() {
        if (!running) {
            checkState(timer == null);

            timer = new java.util.Timer(true); // use daemon thread internally
            schedulePurging(); // schedule timeout to purge cancelled tasks from the timer task queue

            running = true;
        }
    }
478585
@Override
	public void open(Configuration config) throws IOException {
		streamer.open();
		streamer.sendBroadCastVariables(config);
	}
188597
protected void updateLaunchOptionsFromConfig(ILaunchConfiguration config) {
		final boolean runInEclipse = this.accessor.isEmbeddedSRE(config);
		final boolean enableAssertionsRun = this.accessor.isAssertionEnabledInRunMode(config);
		final boolean enableAssertionsDebug = this.accessor.isAssertionEnabledInDebugMode(config);
		this.enableAssertionsInRunModeButton.setSelection(enableAssertionsRun);
		this.enableAssertionsInDebugModeButton.setSelection(enableAssertionsDebug);
		this.runInEclipseButton.setSelection(runInEclipse);
	}
1323174
public void setConfig(Config config) {
        if (mapperHelper == null) {
            mapperHelper = new MapperHelper();
        }
        mapperHelper.setConfig(config);
    }
704659
public void updateConfig(String appName, Map<String, String> config) {
        connection.execute(new ConfigUpdate(appName, config), apiKey);
    }
85653
public void start(VersionsSelectionConfiguration configuration) throws AppEngineException {
    Preconditions.checkNotNull(configuration);
    Preconditions.checkNotNull(configuration.getVersions());
    Preconditions.checkArgument(configuration.getVersions().size() > 0);

    List<String> arguments = new ArrayList<>();
    arguments.add("app");
    arguments.add("versions");
    arguments.add("start");
    arguments.addAll(commonVersionSelectionArgs(configuration));

    execute(arguments);
  }
718987
public static synchronized void init(LogProviderConfig config) {
        if (config == null)
            throw new NullPointerException("LogProviderConfig must not be null");

        if (loggingConfig.compareAndSet(null, config)) {
            // Only initialize FFDC once -- all subsequent changes go through update
            // The synchronization of this method is gratuitous (just makes us feel better), 
            // it is called while the system is single threaded at startup. 

            // config.getTrDelegate() must not return null -- it should either
            // return a dummy/disabled delegate, or throw an exception so that startup
            // does not proceed.
            delegate = config.getFfdcDelegate();
            if (delegate == null)
                throw new NullPointerException("LogProviderConfig must provide a FFDCFilterService delegate");

            delegate.init(config);
        }
    }