Starts execution of the broker.

@return Returns true if the broker completed without interruption, false otherwise
161814
public boolean run() {
      ExecutorService executors = Executors.newFixedThreadPool(producers.size() + consumers.size());
      runningProducers.set(producers.size());

      //create the producers
      for (Producer<V> producer : producers) {
         producer.setOwner(this);
         executors.submit(new ProducerThread(producer));
      }

      //create the consumers
      for (java.util.function.Consumer<? super V> consumer : consumers) {
         executors.submit(new ConsumerThread(consumer));
      }

      //give it some more time to process
      while (runningProducers.get() > 0 || !queue.isEmpty()) {
         Threads.sleep(10);
      }

      executors.shutdown();
      try {
         executors.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
      } catch (InterruptedException e) {
         logWarn(e);
         return false;
      }
      return true;
   }
460214
@Override
  public boolean start()
  {
    if (! _lifecycle.toStarting()) {
      return false;
    }

    _fd = createNative();

    if (_fd == 0) {
      _lifecycle.toDestroy();
      log.finer(this + " is not available on this system.");
      return false;
    }

    String name = "resin-select-manager-" + _gId++;
    _thread = new Thread(new SelectTask(), name);
    _thread.setDaemon(true);
    _thread.setPriority(Thread.MAX_PRIORITY);

    _thread.start();

    _lifecycle.waitForActive(2000);

    if (log.isLoggable(Level.FINER))
      log.finer(this + " active");

    log.fine("Async/poll keepalive enabled with max sockets = "
             + _selectMax);

    name = "resin-select-manager-timeout-" + _gId++;
    Thread timeoutThread = new Thread(new TimeoutTask(), name);
    timeoutThread.setDaemon(true);
    timeoutThread.start();

    return true;
  }
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;
    }
269089
public MessageBroker processAfterStartup(MessageBroker broker) {
        // Eagerly detect possible problems with the Service
        Service service = broker.getServiceByType(getServiceClassName());
        Assert.notNull(service, "The MessageBroker with id '" + broker.getId() + "' does not have a service of type " + getServiceClassName()
            + " configured.");
        Assert.isTrue(service.isStarted(), "The Service with id '" + service.getId() + "' of MessageBroker with id '" + broker.getId()
            + "' was not started as expected.");
        return broker;
    }
1360295
protected final void started() {
    if (!state.compareAndSet(State.STARTING, State.ALIVE)) {
      LOG.info("Program already started {} {}", programName, runId);
      return;
    }
    LOG.info("Program started: {} {}", programName, runId);
    executor(State.ALIVE).execute(new Runnable() {
      @Override
      public void run() {
        state.set(State.ALIVE);
        caller.alive();
      }
    });
  }
1140567
@Override
  public boolean start()
  {
    if (! _lifecycle.toStarting()) {
      return false;
    }

    log.isLoggable(Level.FINER);

    String name = "resin-nio-select-manager-" + _gId++;
    _thread = new Thread(this, name);
    _thread.setDaemon(true);

    _thread.start();

    _lifecycle.waitForActive(2000);

    if (log.isLoggable(Level.FINER))
      log.finer(this + " active");

    log.fine("Non-blocking keepalive enabled with max sockets = "
             + _selectMax);

    return true;
  }
629593
private boolean start() {
        if (scheduledFuture == null || scheduledFuture.isCancelled()) {
            scheduledFuture = scheduler.scheduleWithFixedDelay(cacheManagingTask, delay, delay, TimeUnit.MINUTES);
            if (LOG.isDebugEnabled()) {
                LOG.debug("{} Cache Manager Started.", cache.getClass().getSimpleName());
            }
            return true;
        }
        return false;
    }
397070
@Override
	public void started(ServiceBroker broker) throws Exception {
		super.started(broker);
		if (prefix == null) {
			prefix = (broker.getNodeID() + ':').toCharArray();
		}
	}
425981
public function transactionStart()
    {
        if (empty($this->oDb)) {
            $this->connect();
        }

        try {

            $this->oDb->beginTransaction();
            $this->transactionRunning = true;

            return true;

        } catch (\Exception $e) {
            throw new TransactionException($e->getMessage(), $e->getCode());
        }
    }
247154
public boolean masterStarted() {
        if (objectMapper == null)
            objectMapper = new ObjectMapper();

        try {
            String type = objectMapper.readValue(
                            Unirest.get(String.format("http://%s:%d/opType", masterStatusHost, masterStatusPort)).asJson()
                                            .getBody().toString(),
                            ServerTypeJson.class).getType();
            if (!type.equals("master"))
                throw new IllegalStateException("Wrong opType " + type);
            Unirest.get(String.format("http://%s:%d/started", masterStatusHost, masterStatusPort)).asJson().getBody();
            return objectMapper.readValue(
                            Unirest.get(String.format("http://%s:%d/started", masterStatusHost, masterStatusPort))
                                            .asJson().getBody().toString(),
                            MasterStatus.class).started();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
705642
public void start() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "start");
        }
        if (!this.bRunning) {
            this.ncsaLog.start();
            this.frcaLog.start();
            this.debugLog.start();
            this.bRunning = true;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "start");
        }
    }
380277
public boolean start() {
        Intent emailIntent = build();
        try {
            startActivity(emailIntent);
        } catch (ActivityNotFoundException e) {
            return false;
        }

        return true;
    }
990521
@Pure
	public boolean isStartingBusHalt() {
		final BusItinerary itinerary = getContainer();
		if (itinerary != null && itinerary.isValidPrimitive()) {
			try {
				return itinerary.getBusHaltAt(0) == this;
			} catch (IndexOutOfBoundsException exception) {
				// invalid halt
			}
		}
		return false;
	}
65206
public boolean start() {
        if (!this.isTailing.compareAndSet(false, true)) {
            return false;
        }
        final boolean willReadFromEnd = this.willReadFromEnd();
        LogWatchTailingManager.LOGGER.debug("Tailer {} ignore existing file contents.", willReadFromEnd ? "will"
                : "won't");
        this.tailer = new SplitlogTailer(this.watch.getWatchedFile(), new LogWatchTailerListener(this),
                this.delayBetweenReads, this.willReadFromEnd(), this.reopenBetweenReads, this.bufferSize);
        LogWatchTailingManager.EXECUTOR.submit(this.tailer);
        final long start = System.nanoTime();
        this.tailer.waitUntilStarted();
        final long duration = System.nanoTime() - start;
        LogWatchTailingManager.LOGGER.debug("It took {} ms for the tailing to actually start.",
                TimeUnit.NANOSECONDS.toMillis(duration));
        final long iterationNum = this.numberOfTimesThatTailerWasStarted.incrementAndGet();
        LogWatchTailingManager.LOGGER.info("Tailing #{} started for {}.", iterationNum, this.watch);
        return true;
    }
801118
public boolean toStopping()
  {
    LifecycleState state;
    
    synchronized (this) {
      state = _state;
      
      if (state.isAfterStopping() || state.isStarting()) {
        return false;
      }
      
      _state = STOPPING;

      _lastChangeTime = CurrentTime.currentTime();
    }

    if (_log != null && _log.isLoggable(_level)) {
      _log.log(_level, "stopping " + _name);
    }

    notifyListeners(state, STOPPING);

    return true;
  }
696019
public static boolean isAllReady() throws IOException, InterruptedException {
        for (RestartListener listener : all()) {
            if (!listener.isReadyToRestart())
                return false;
        }
        return true;
    }
1065882
@Override
    public final void run() {
        for (; ; ) {
            final BaasHandler<?> curr = suspendableHandler.get();
            // at this stage we are in the callback thread of execution
            // we get the current handler and choose the state to reach
            if (curr == Signal.COMMITTED) {
                //the callback has already run
                // really we don't have to make any work
                return;
            }

            final BaasHandler<?> target;
            if (curr == Signal.SUSPENDED || curr == Signal.DELIVERED) {
                //if the current state is SUSPENDED the target state
                //to reach is DELIVERED
                //handlers in DELIVERED state won't change and remain the same
                //so for both the cases the target state would be
                // DELIVERED and there would be no more work to do
                target = Signal.DELIVERED;
            } else {
                // we have a real handler to execute
                // and we need to commit the execution
                target = Signal.COMMITTED;
            }

            if (suspendableHandler.compareAndSet(curr, target)) {
                //at this point the transition is completed
                //if the target we reached is COMMITTED than we have
                //to execute the callback and cleanup the dispatcher
                if (target == Signal.COMMITTED) {
                    if (curr != null) {
                        ((BaasHandler<R>) curr).handle(result);
                    }
                    finish();
                }
                return;
            }
        }
    }