Starts a trampoline to process the queue.
979551
function trampoline(queue) {
  index = [0];
  stack = [queue];

  var queueIndex, queueLength;

  var stackIndex = 1; // 1-indexed!
  var stackLength = stack.length;
  var topOfStack = true;
  while (stackIndex) {
    queue = stack[stackIndex - 1];
    queueIndex = index[stackIndex - 1];
    if (queueIndex === -1) {
      queueIndex = index[stackIndex - 1] = 0;
    }
    queueLength = queue.length;

    while (queueIndex < queueLength && topOfStack) {
      queue[queueIndex].resolve(
          queue[queueIndex + 1],
          queue[queueIndex + 2],
          queue[queueIndex + 3]);

      queueIndex += 4;
      stackLength = stack.length;
      topOfStack = stackLength === stackIndex;
    }

    if (!topOfStack) {
      index[stackIndex - 1] = queueIndex;
      stackIndex = stackLength;
      topOfStack = true;
    } else {
      index.pop();
      stack.pop();
      stackIndex--;
    }
  }
  stack = index = null;
}
936631
public void start()
    {
        if (mAnimations.size() == 0)
        {
            return;
        }
        mIsRunning = true;
        for (GVRAnimation anim : mAnimations)
        {
            anim.start(getGVRContext().getAnimationEngine());
        }
    }
1239806
def start debug=false,method=:every_minute,*args
      @stopped = false
      @suspended = false
      @dead = Queue.new
      @thread = CronR::Utils.send(method,debug,*args) {
        time = self.time
        @mutex.synchronize {
          if @stopped then
            # It's important we put something on this queue ONLY AFTER
            # we've acquired the mutex...
            @dead.enq(true)
            true
          elsif @suspended then
          else
            self.run(time)
          end
        }
      }
    end
588314
def run(self):
        
        try:
            self._loop()
        except Exception:
            # Send the exception through the exc_queue, so the parent
            # process can check it.
            typ, val, tb = sys.exc_info()
            tb_lines = traceback.format_exception(typ, val, tb)
            self.exc_queue.put((val, tb_lines))
1080276
public void start() {
    int numThreads = Runtime.getRuntime().availableProcessors();
    ThreadFactory factory = ThreadFactories.withName("ServoPollScheduler-%d");
    start(Executors.newScheduledThreadPool(numThreads, factory));
  }
75335
def run(self):
        
        LOGGER.debug('Initializing process')

        # Setup logging
        self.logging_config = self.setup_logging()

        # Register the signal handlers
        self.setup_signal_handlers()

        # Create the application instance
        try:
            self.app = self.create_application()
        except exceptions.NoRoutesException:
            return

        # Create the HTTPServer
        self.http_server = self.create_http_server()

        # Hold on to the IOLoop in case it's needed for responding to signals
        self.ioloop = ioloop.IOLoop.instance()

        # Start the IOLoop, blocking until it is stopped
        try:
            self.ioloop.start()
        except KeyboardInterrupt:
            pass
403402
async def start(self) -> None:
        """"""
        if self._is_running:
            raise SublemonRuntimeError(
                'Attempted to start an already-running `Sublemon` instance')

        self._poll_task = asyncio.ensure_future(self._poll())
        self._is_running = True
636449
def start(self, *args, **kwargs):
        """"""

        self.queue = Queue()
        thread = Thread(target=self._threaded, args=args, kwargs=kwargs)
        thread.start()

        return Asynchronous.Result(self.queue, thread)
1328949
public void runQueue() {
    synchronized(sync) {
      while(!queue.isEmpty()) {
        Runnable r = queue.poll();
        if(r != null) {
          try {
            r.run();
          }
          catch(Exception e) {
            // Alternatively, we could allow the specification of exception
            // handlers for each runnable in the API. For now we'll just log.
            // TODO: handle exceptions here better!
            LoggingUtil.exception(e);
          }
        }
        else {
          LoggingUtil.warning("Tried to run a 'null' Object.");
        }
      }
    }
  }
436748
def start(self):
        
        self.running = True
        self.thread = threading.Thread(target=self._main_loop)
        self.thread.start()
1211990
def start(self):
        """"""
        self._lc = LoopingCall(self._download)
        # Run immediately, and then every 30 seconds:
        self._lc.start(30, now=True)
271962
public void start()
    throws Exception
  {
    if (_port < 0 && _unixPath == null) {
      return;
    }

    if (! _lifecycle.toStarting())
      return;

    boolean isValid = false;
    try {
      bind();
      postBind();

      enable();

      _acceptTask = new AcceptTcp(this, _serverSocket);
      _threadPool.execute(_acceptTask);

      // _connThreadPool.start();

      _suspendAlarm = new Alarm(new SuspendReaper());
      _suspendAlarm.runAfter(_suspendReaperTimeout);

      isValid = true;
    } finally {
      if (! isValid) {
        close();
      }
    }
  }
88177
def start(self):
        """"""

        if self._started is True:
            raise ArgumentError("EmulationLoop.start() called multiple times")

        self._thread = threading.Thread(target=self._loop_thread_main)
        self._thread.start()
        self._started = True
713495
@Override
  protected void startUp() {
    log.info("Starting the " + getClass().getSimpleName());
    log.info("Polling git with interval {} ", this.pollingInterval);

    // Schedule the job config fetch task
    this.scheduledExecutor.scheduleAtFixedRate(new Runnable() {
      @Override
      public void run() {
        try {
          if (shouldPollGit()) {
            processGitConfigChanges();
          }
        } catch (GitAPIException | IOException e) {
          log.error("Failed to process git config changes", e);
          // next run will try again since errors could be intermittent
        }
      }
    }, 0, this.pollingInterval, TimeUnit.SECONDS);
  }
476040
def start(self):
        
        self.__stop = False
        self._queue.start()
        self._zk.start()
639257
protected function start()
    {
        if ($this->isRunning($this->getCurrentPid())) {
            $this->error('Failed! swoole_http_server process is already running.');

            return;
        }

        $host = Arr::get($this->config, 'server.host');
        $port = Arr::get($this->config, 'server.port');
        $hotReloadEnabled = Arr::get($this->config, 'hot_reload.enabled');
        $accessLogEnabled = Arr::get($this->config, 'server.access_log');

        $this->info('Starting swoole http server...');
        $this->info("Swoole http server started: <http://{$host}:{$port}>");
        if ($this->isDaemon()) {
            $this->info(
                '> (You can run this command to ensure the ' .
                'swoole_http_server process is running: ps aux|grep "swoole")'
            );
        }

        $manager = $this->laravel->make(Manager::class);
        $server = $this->laravel->make(Server::class);

        if ($accessLogEnabled) {
            $this->registerAccessLog();
        }

        if ($hotReloadEnabled) {
            $manager->addProcess($this->getHotReloadProcess($server));
        }

        $manager->run();
    }
480169
public function run()
    {
        $this->init();

        // Loop forever, except when a maximum number of requests is configured
        $requestsHandled = 0;
        while ($this->maxRequests === null || $requestsHandled < $this->maxRequests) {
            $this->doStep();
            $requestsHandled++;
        }
    }