{@link WebDriverSessionHandler#start()} will start a child thread that will keep pooling the title of the page so
the the web session will not get timeout.
484875
public void start() {

        logger.entering();

        if (bStartSession) {
            throw new IllegalStateException("WebDriverSessionHandler is already started");
        }

        bStartSession = true;

        result = Executors.newSingleThreadExecutor().submit(webDriverCaller);
        logger.exiting();

    }
815097
@Override
    public void start() {
        if (started) {
            return;
        }
        ApplicationHandler handler = getApplicationHandler();
        if (handler == null) {
            throw new IllegalStateException("ApplicationHandler cannot be null");
        }
        handler.onStartup(this);
        started = true;
    }
711818
@Override
	public void onStart() throws Exception {
		try {
			startTaskExecutorServices();
		} catch (Exception e) {
			final TaskManagerException exception = new TaskManagerException(String.format("Could not start the TaskExecutor %s", getAddress()), e);
			onFatalError(exception);
			throw exception;
		}

		startRegistrationTimeout();
	}
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);
    }
  }
407998
public void start() throws ServerLifecycleException {
		try {
			contextHandlerCollection.addHandler(contextHandler);
			contextHandlerCollection.mapContexts();
			contextHandler.start();
			LOG.info("WebDavServlet started: " + contextPath);
		} catch (Exception e) {
			throw new ServerLifecycleException("Servlet couldn't be started", e);
		}
	}
102864
@Override
	public WebPage run(WebPage initialPage) {
		if(getUser() == null)
			throw new IllegalStateException("the user set is null");
		WebPage currentPage = initialPage;
		for(WebTask task : this) {
			logger.info("BEGIN subtask " + task.getClass().getSimpleName());
			// before running the subtask, set the user
			task.setUser(getUser());
			currentPage = task.run(currentPage);
			logger.info("END subtask " + task.getClass().getSimpleName());
		}
		return currentPage;
	}
1272444
void start() {
    final ContextStart contextStart = new ContextStartImpl(this.identifier);
    for (final EventHandler<ContextStart> startHandler : this.contextStartHandlers) {
      startHandler.onNext(contextStart);
    }
  }
591034
@Override
	public void start() throws Exception {
		synchronized (lock) {
			if (jobExecutorService == null) {
				// create the embedded runtime
				jobExecutorServiceConfiguration = createConfiguration();

				// start it up
				jobExecutorService = createJobExecutorService(jobExecutorServiceConfiguration);
			} else {
				throw new IllegalStateException("The local executor was already started.");
			}
		}
	}
1193021
public void run()
    {
        try
        {
            log.debug("CLOCK: Starting server-side thread");

            while (active)
            {
                Collection<ScriptSession> sessions = sctx.getScriptSessionsByPage("/dwr/clock/index.html");
                Util pages = new Util(sessions);
                pages.setValue("clockDisplay", new Date().toString());

                log.debug("Sent message");
                Thread.sleep(1000);
            }

            Collection<ScriptSession> sessions = sctx.getScriptSessionsByPage("/dwr/clock/index.html");
            Util pages = new Util(sessions);
            pages.setValue("clockDisplay", "");

            log.debug("CLOCK: Stopping server-side thread");
        }
        catch (InterruptedException ex)
        {
            ex.printStackTrace();
        }
    }
1109790
public void start() {
    if (log.isLoggable(Level.FINE)) {
      log.fine(String.format("Starting command: %s", commandString()));
    }
    ProcessBuilder builder = new ProcessBuilder(args);
    if (workingDir != null) {
      builder.directory(workingDir);
    }
    if (!environment.isEmpty()) {
      Map<String, String> env = builder.environment();
      env.putAll(environment);
    }

    try {
      process = builder.start();
    } catch (IOException e) {
      throw new WebDriverException("failed to start process " + args, e);
    }

    threads.add(listen(process.getInputStream(), out, true));
    threads.add(listen(process.getErrorStream(), err, false));
  }
1051200
@Override
	public final void start() throws JMSException
    {
    	externalAccessLock.readLock().lock();
    	try
		{
	        checkNotClosed();
	        if (started)
	            return;
	        started = true;
		}
    	finally
    	{
    		externalAccessLock.readLock().unlock();
    	}
    	transportEndpoint.blockingRequest(new StartConnectionQuery());
    }
652645
@LifecycleStart
  @Override
  public void start() throws Exception
  {
    super.start();

    synchronized (lifecycleLock) {
      Preconditions.checkState(!started, "already started");
      started = true;

      try {
        cleanupStaleAnnouncements();
        registerRunListener();
        pathChildrenCache.start();

        log.info("Started WorkerTaskMonitor.");
        started = true;
      }
      catch (InterruptedException e) {
        throw e;
      }
      catch (Exception e) {
        log.makeAlert(e, "Exception starting WorkerTaskMonitor")
           .emit();
        throw e;
      }
    }
  }
34092
public void start() {
        if (workers != null) throw new UnsupportedOperationException("Please shutdown connector!");

        if (LOGGER.isLoggable(Level.INFO))
            LOGGER.info("Starting " + name + " with " + config.getWorkerCount() + " workers");

        handlers = new ConcurrentLinkedQueue<TcpServerHandler>();
        handlers.add(new TcpServerAcceptor(config, handlers));

        workers = new Thread[config.getWorkerCount()];
        for (int i = 0; i < workers.length; i++) {
            workers[i] = new TcpServerWorker(handlers);
        }

        for (final Thread worker : workers) worker.start();

        if (LOGGER.isLoggable(Level.INFO))
            LOGGER.info(name + " started");
    }
1373730
@Override
	public void start() {
		try {
			url = new URL(getStringSetting(SETTING_URL, DEFAULT_STACKDRIVER_API_URL));
		} catch (MalformedURLException e) {
			throw new EmbeddedJmxTransException(e);
		}

		apiKey = getStringSetting(SETTING_TOKEN);

		if (getStringSetting(SETTING_PROXY_HOST, null) != null && !getStringSetting(SETTING_PROXY_HOST).isEmpty()) {
			proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(getStringSetting(SETTING_PROXY_HOST), getIntSetting(SETTING_PROXY_PORT)));
		}
		
		logger.info("Starting Stackdriver writer connected to '{}', proxy {} ...", url, proxy);
		

		stackdriverApiTimeoutInMillis = getIntSetting(SETTING_STACKDRIVER_API_TIMEOUT_IN_MILLIS, DEFAULT_STACKDRIVER_API_TIMEOUT_IN_MILLIS);

		// try to get and instance ID
		if (getStringSetting(SETTING_SOURCE_INSTANCE, null) != null && !getStringSetting(SETTING_SOURCE_INSTANCE).isEmpty()) {
			// if one is set directly use that
			instanceId = getStringSetting(SETTING_SOURCE_INSTANCE);
			logger.info("Using instance ID {} from setting {}", instanceId, SETTING_SOURCE_INSTANCE);
		} else if (getStringSetting(SETTING_DETECT_INSTANCE, null) != null && "AWS".equalsIgnoreCase(getStringSetting(SETTING_DETECT_INSTANCE))) {
			// if setting is to detect, look on the local machine URL
			logger.info("Detect instance set to AWS, trying to determine AWS instance ID");
			instanceId = getLocalAwsInstanceId();
			if (instanceId != null) {
				logger.info("Detected instance ID as {}", instanceId);
			} else {
				logger.info("Unable to detect AWS instance ID for this machine, sending metrics without an instance ID");
			}
		} else {
			// no instance ID, the metrics will be sent as "bare" custom metrics and not associated with an instance
			instanceId = null;
			logger.info("No source instance ID passed, and not set to detect, sending metrics without and instance ID");
		}
		
	}
800937
public boolean start() throws IOException {
        if (mThread != null) {
            return false;
        }

        mThread = new Thread(this, "Local View Server [port=" + mPort + "]");
        mThreadPool = Executors.newFixedThreadPool(VIEW_SERVER_MAX_CONNECTIONS);
        mThread.start();

        return true;
    }
760385
public void start() {
        if (this.started) {
            throw new IllegalStateException("Cannot start the EventStream because it isn't stopped.");
        }

        final long initialPosition;

        if (this.startingPosition == STREAM_POSITION_NOW) {
            BoxAPIRequest request = new BoxAPIRequest(this.api, EVENT_URL.build(this.api.getBaseURL(), "now"), "GET");
            BoxJSONResponse response = (BoxJSONResponse) request.send();
            JsonObject jsonObject = JsonObject.readFrom(response.getJSON());
            initialPosition = jsonObject.get("next_stream_position").asLong();
        } else {
            assert this.startingPosition >= 0 : "Starting position must be non-negative";
            initialPosition = this.startingPosition;
        }

        this.poller = new Poller(initialPosition);

        this.pollerThread = new Thread(this.poller);
        this.pollerThread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            public void uncaughtException(Thread t, Throwable e) {
                EventStream.this.notifyException(e);
            }
        });
        this.pollerThread.start();

        this.started = true;
    }
786927
protected synchronized void doStart() throws Exception
    {
        // Start Servlet Handler
        super.doStart();
        if (log.isDebugEnabled())
            log.debug("Path Filters: " + _pathFilters);
        if (log.isDebugEnabled())
            log.debug("Servlet Filters: " + _servletFilterMap);
        
        if (getHttpContext() instanceof WebApplicationContext)
            _webApplicationContext= (WebApplicationContext)getHttpContext();
        
        if (_filterChainsCached)
        {
            _chainCache = getChainCache();
            _namedChainCache = getChainCache();
        }
    }