Start the BatchedTimeoutManager
519441
public void startTimer()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    	SibTr.entry(tc, "startTimer");
    btmLockManager.lockExclusive();
    try
    {
      //only start if currently stopped
      if (isStopped)
      {
        //set stopped to false
        isStopped = false;
        //iterate over the entries currently in the active list
        LinkedListEntry entry = (LinkedListEntry) activeEntries.getFirst();
        while(entry != null && activeEntries.contains(entry))
        {
          //start an alarm for each entry
          startNewAlarm(entry);
          entry = (LinkedListEntry) entry.getNext();
        }
      }
    }
    finally
    {
      btmLockManager.unlockExclusive();
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    	SibTr.exit(tc, "startTimer");
  }
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;
		}
	}
330807
def start(self):
        
        with self._operational_lock:
            if self._thread is not None:
                raise ValueError("Dispatcher is already running.")

            flow_control = self._manager.flow_control
            worker = helper_threads.QueueCallbackWorker(
                self._queue,
                self.dispatch_callback,
                max_items=flow_control.max_request_batch_size,
                max_latency=flow_control.max_request_batch_latency,
            )
            # Create and start the helper thread.
            thread = threading.Thread(name=_CALLBACK_WORKER_NAME, target=worker)
            thread.daemon = True
            thread.start()
            _LOGGER.debug("Started helper thread %s", thread.name)
            self._thread = thread
1160770
def start(self):
        
        self._timer = Timer(self.time, self.handler)
        self._timer.daemon = True
        self._timer.start()
        return
563650
@Override
	public void init(IBatchConfig batchConfig)
			throws BatchContainerServiceException {
		
		String method = "init";
		if(logger.isLoggable(Level.FINER)) { logger.entering(sourceClass, method);	}
		
		String maxThreadPoolSizeStr = batchConfig.getConfigProperties().
				getProperty(BOUNDED_THREADPOOL_MAX_POOL_SIZE, defaultMaxThreadPoolSize); 
		
		int maxThreadPoolSize = Integer.parseInt(maxThreadPoolSizeStr);
		
		if(logger.isLoggable(Level.FINE)) { 
			logger.fine("Glassfish thread pool settings: (" + minThreadPoolSize + "," +  maxThreadPoolSize + "," 
		                 + idleThreadTimeout + "," + TimeUnit.SECONDS + "," + maxQueueSize + ")");  
		}
		
		BlockingQueue<Runnable> queue = null;
		if (maxQueueSize == -1) {
			queue = new LinkedBlockingQueue<Runnable>();
		} else {
			queue = new LinkedBlockingQueue<Runnable>(maxQueueSize);
		}
		
		executorService = new ThreadPoolExecutor(minThreadPoolSize, maxThreadPoolSize, idleThreadTimeout, TimeUnit.SECONDS, queue);  
		
		if(logger.isLoggable(Level.FINER)) { logger.exiting(sourceClass, method);	}
	}
447349
def start(self):
        
        self.thread_handler.run(target=self.start_blocking)
        self.thread_handler.start_run_loop()
650002
function _startTimeout(o, t) {
        _timeout[o.id] = w.setTimeout(function() { _ioCancel(o, 'timeout'); }, t);
    }
866904
function startControlsTimeOut () {

      clearTimeout(controlsTimeout);

      if (controlsElement.style.display === "block") {
        controlsTimeout = setTimeout(function () {
          toggleControls();
        }, 5000);
      } else {
        toggleControls();
      }
    }
1036063
public static void start(String name) {
    if (!active) return;

    TimerNode root = new TimerNode(name, System.currentTimeMillis());
    TimerStack stack = (TimerStack) curStack.get();
    if (null == stack) curStack.set(new TimerStack(root));
    else stack.push(root);
  }
776483
function start(): void {
        if($this->nativeHrtime) {
            $this->timer = \hrtime(true);
        } elseif($this->hrtime) {
            $this->timer->start();
        } else {
            $this->timer = \microtime(true);
        }
    }
70227
def _start(self):
        
        try:
            self._polling_method.run()
        except Exception as err:
            self._exception = err

        finally:
            self._done.set()

        callbacks, self._callbacks = self._callbacks, []
        while callbacks:
            for call in callbacks:
                call(self._polling_method)
            callbacks, self._callbacks = self._callbacks, []
210315
def start(self, timeout=None):
        
        if not self._ioloop:
            raise RuntimeError('Call get_ioloop() or set_ioloop() first')

        self._ioloop.add_callback(self._running.set)

        if self._ioloop_managed:
            self._run_managed_ioloop()
        else:            #  TODO this seems inconsistent with what the docstring describes
            self._running.set()

        if timeout:
            return self._running.wait(timeout)
949352
private void start() {
        setStatus(STARTING);
        jobListener.beforeJobStart(parameters);
        recordTracker = new RecordTracker();
        metrics.setStartTime(System.currentTimeMillis());
        LOGGER.info("Batch size: {}", parameters.getBatchSize());
        LOGGER.info("Error threshold: {}", formatErrorThreshold(parameters.getErrorThreshold()));
        LOGGER.info("Jmx monitoring: {}", parameters.isJmxMonitoring());
        registerJobMonitor();
    }
907015
def resetTimeout(self):
        """"""
        if self.__timeoutCall is not None and self.timeOut is not None:
            self.__timeoutCall.reset(self.timeOut)
264186
def _start_timeout():
    """"""
    global _timeout

    LOGGER.debug('Adding a new timeout in %i ms', _timeout_interval)
    _maybe_stop_timeout()
    _timeout = ioloop.IOLoop.current().add_timeout(
        ioloop.IOLoop.current().time() + _timeout_interval / 1000.0,
        _on_timeout)
379819
public void execute(CommandHandler handler,
            int timeout,
            TimeUnit unit) throws
            CommandLineException,
            InterruptedException, ExecutionException, TimeoutException {
        ExecutableBuilder builder = new ExecutableBuilder() {
            CommandContext c = newTimeoutCommandContext(ctx);
            @Override
            public Executable build() {
                return () -> {
                    handler.handle(c);
                };
            }

            @Override
            public CommandContext getCommandContext() {
                return c;
            }
        };
        execute(builder, timeout, unit);
    }
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