Start the parent that will simply run the child forever until stopped.
545165
def start_parent():
    

    while True:
        args = [sys.executable] + sys.argv
        new_environ = environ.copy()
        new_environ["_IN_CHILD"] = 'yes'
        ret = subprocess.call(args, env=new_environ)

        if ret != settings.CODE_RELOAD_EXIT:
            return ret
433482
async def _start(self):
        
        self.agent._alive.wait()
        try:
            await self.on_start()
        except Exception as e:
            logger.error("Exception running on_start in behaviour {}: {}".format(self, e))
            self.kill(exit_code=e)
        await self._step()
        self._is_done.clear()
1324853
@Override
    public void start()
    {
        try {
            m_leaderCache = new LeaderCache(m_zk, "MpTerm-iv2masters", VoltZK.iv2masters, m_leadersChangeHandler);
            m_leaderCache.start(true);
        }
        catch (ExecutionException ee) {
            VoltDB.crashLocalVoltDB("Unable to create babysitter starting term.", true, ee);
        } catch (InterruptedException e) {
            VoltDB.crashLocalVoltDB("Unable to create babysitter starting term.", true, e);
        }
    }
238229
def start(self):
        '''
        
        '''
        self._handler = _create_handler_class(self._rules, self._always_rules)
        self._server = HTTPServer(('', self._port), self._handler)
        self._thread = Thread(target=self._server.serve_forever, daemon=True)
        self._thread.start()
        self.running = True
        return self
664846
def start(self):
        """"""
        self.stop()
        self.initialize()
        self.handle = self.loop.call_at(self.get_next(), self.call_next)
476040
def start(self):
        
        self.__stop = False
        self._queue.start()
        self._zk.start()
1191420
def run_forever(self):
        """"""
        res = self.slack.rtm.start()
        self.log.info("current channels: %s",
                      ','.join(c['name'] for c in res.body['channels']
                               if c['is_member']))
        self.id = res.body['self']['id']
        self.name = res.body['self']['name']
        self.my_mention = "<@%s>" % self.id

        self.ws = websocket.WebSocketApp(
            res.body['url'],
            on_message=self._on_message,
            on_error=self._on_error,
            on_close=self._on_close,
            on_open=self._on_open)
        self.prepare_connection(self.config)
        self.ws.run_forever()
243339
def stop(self):
        
        self.child.terminate()
        self._cleanup()
        return self.child.exitcode
381330
def run(self, once=False):
        """"""
        self._once = once
        self.start()
        while self.running:
            try:
                time.sleep(1.0)
            except KeyboardInterrupt:
                self.stop()
                self.join()
1260624
def start(self):
        
        if self._started:
            raise RuntimeError("thread already started")

        def run():
            try:
                self.run(*self._args, **self._kwargs)
            except SystemExit:
                # only shut down the thread, not the whole process
                pass
            finally:
                self._deactivate()

        self._glet = scheduler.greenlet(run)
        self._ident = id(self._glet)
        scheduler.schedule(self._glet)
        self._activate()
277716
def run(self):
    """"""
    while not self._state.is_terminating:
      self._process_event_queue()
      self._state.maybe_pause()
552248
def run_forever(self, **kwargs):
        
        for key in kwargs:
            setattr(self, key, kwargs[key])
        self.command = self.COMMAND_RUN_FOREVER
419752
public static void start() {

        if (!CmsCoreProvider.get().isKeepAlive()) {
            return;
        }

        if (INSTANCE == null) {
            m_keepRunning = true;
            CmsBroadcastTimer timer = new CmsBroadcastTimer();
            timer.getBroadcast();
            timer.run();
            INSTANCE = timer;
        }
    }
358516
def start(self, *args, **kwargs):
        
        self._stop = False

        super(Plant, self).start(*args, **kwargs)
1174468
def run(self):
        
        setproctitle.setproctitle("{:s}: {:s}".format(
            self.context.config.name, self.__class__.__name__))
        self.logger.info(
            "Worker '%s' has been started with pid %d",
            self.__class__.__name__, os.getpid())

        # Register SIGINT handler which will exit service process
        def sigint_handler(unused_signum, unused_frame):
            """
            Exit service process when SIGINT is reached.
            """
            self.stop()
        signal.signal(signal.SIGINT, sigint_handler)

        # Initialize logging
        self.context.config.configure_logging()
        # Initialize child
        self.context.initialize_child(SERVICE_PROCESS, process=self)

        next_loop_time = 0
        while 1:
            # Exit if pid of the parent process has changed (parent process
            # has exited and init is new parent) or if stop flag is set.
            if os.getppid() != self._parent_pid or self._stop_event.is_set():
                break
            # Repeatedly call loop method. After first call set ready flag.
            if time.time() >= next_loop_time:
                try:
                    self.loop()
                except Exception:
                    self.logger.exception(
                        "Worker '%s' failed", self.__class__.__name__)
                else:
                    if not next_loop_time and not self.ready:
                        self._ready.value = True
                next_loop_time = time.time() + self.interval
            else:
                time.sleep(0.25)
1211990
def start(self):
        """"""
        self._lc = LoopingCall(self._download)
        # Run immediately, and then every 30 seconds:
        self._lc.start(30, now=True)
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);
        }
    }