Starts the manager if needed
547113
private static void startIfNeeded()
   {
      if (!STARTED)
      {
         synchronized (JCRStatisticsManager.class)
         {
            if (!STARTED)
            {
               addTriggers();
               ExoContainer container = ExoContainerContext.getTopContainer();
               ManagementContext ctx = null;
               if (container != null)
               {
                  ctx = container.getManagementContext();
               }
               if (ctx == null)
               {
                  LOG.warn("Cannot register the statistics");
               }
               else
               {
                  ctx.register(new JCRStatisticsManager());
               }
               STARTED = true;
            }
         }
      }
   }
436748
def start(self):
        
        self.running = True
        self.thread = threading.Thread(target=self._main_loop)
        self.thread.start()
75712
def start(self):
        
        with self._mgr_lock:
            with self._lock:
                self._use_count += 1

            if self._thread is None:
                self._create_all()
                self._thread = threading.Thread(target=self._thread_func)
                self._thread.setDaemon(SysConfig.get_all_thread_daemon())
                self._thread.start()
854634
def start(self):
        """"""
        self.agent.submit(self._start())
        self.is_running = True
982651
public function start()
    {
        $this->manager->start($this);

        if (!$this->referenced) {
            $this->manager->unreference($this);
        }
    }
943797
private void start() {
        if (m_bRunning) {
            m_logger.warn("start: Already started -- ignoring");
            return;
        }
        Locale.setDefault(Locale.ROOT);
        m_logger.info("Doradus Version: {}", getDoradusVersion());
        hookShutdownEvent();
        startServices();
        m_bRunning = true;
    }
1076364
private void startMaster() throws IOException, ConnectionFailedException {
    mMaster = AlluxioJobMasterProcess.Factory.create();

    ServerConfiguration
        .set(PropertyKey.JOB_MASTER_RPC_PORT, String.valueOf(mMaster.getRpcAddress().getPort()));
    Runnable runMaster = new Runnable() {
      @Override
      public void run() {
        try {
          mMaster.start();
        } catch (Exception e) {
          throw new RuntimeException(e + " \n Start Master Error \n" + e.getMessage(), e);
        }
      }
    };
    mMasterThread = new Thread(runMaster);
    mMasterThread.start();
  }
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));
  }
102880
public function start(): void
    {
        $classAndMethodName = $this->classNameGenerator->getClassAndMethodNamesForCalling();

        $this->executor->exec(...$classAndMethodName);
    }
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
978823
final void start() {
        _enabled = true;
        _ignoredSegs.clear();
        _executor = Executors.newSingleThreadExecutor(new DaemonThreadFactory());
        _executor.execute(this);
    }
358516
def start(self, *args, **kwargs):
        
        self._stop = False

        super(Plant, self).start(*args, **kwargs)
1150545
def start(self):
        
        log.info("WSSAPI.start(): Starting Basic Facilities")
        self.running = True
        if self._controller_thread is None or not self._controller_thread.is_alive():
            self._controller_thread = Thread(target=self._controller,
                                             daemon=True,
                                             name='%s Controller Thread' %
                                                  self.name)
            self._controller_thread.start()
1236275
def start(self, *_):
        
        self.logger.info('Starting Scheduler...')
        db_manager.synch_db()
        self._load_managed_entries()

        try:
            self._load_freerun_entries()
        except LookupError as e:
            self.logger.warning('DB Lookup: {0}'.format(e))

        # Scheduler is initialized and running. GarbageCollector can be safely started
        self.gc.start()

        # Job/UOW Status Listeners can be safely started
        self.uow_listener.start()
        self.job_listener.start()

        self.logger.info('Startup Sequence Completed. Starting MX.')
        # Management Extension (MX) should be the last to start
        self.mx.start()
182987
public void start() {
        ObjectName beanName = null;
        try {
            MBeanServer server = ManagementFactory.getPlatformMBeanServer();
            beanName = getObjectName();
            server.registerMBean(this, beanName);
        } catch (InstanceAlreadyExistsException e) {
            LOGGER.warn(JcrI18n.mBeanAlreadyRegistered, beanName);
        } catch (Exception e) {
            LOGGER.error(e, JcrI18n.cannotRegisterMBean, beanName);
        }
    }
447349
def start(self):
        
        self.thread_handler.run(target=self.start_blocking)
        self.thread_handler.start_run_loop()
985603
public void start() {
        FixedSchedulerPool update = new FixedSchedulerPool(poolSize);
        if (!pool.compareAndSet(NONE, update)) {
            update.shutdown();
        }
    }