/*
(non-Javadoc)
@see org.picocontainer.Startable#start()
513886
public void start()
   {
      // responsible for:
      // 1. reading parameters (such as repoWorkspaceName, repoPath) from
      // registryService (if present) or init params
      // 2. initializing artifact service Registry Entry if registryService is
      // present
      // if Entry is not initialized yet (first launch)
      // 3. initializing maven root if not initialized

      if (LOG.isDebugEnabled())
      {
         LOG.debug("Starting ArtifactManagingService ...");
      }

      sessionProvider = SessionProvider.createSystemProvider();

      try
      {
         InputStream xml = getClass().getResourceAsStream(NT_FILE);
         ManageableRepository rep = repositoryService.getCurrentRepository();
         rep.getNodeTypeManager().registerNodeTypes(xml, ExtendedNodeTypeManager.IGNORE_IF_EXISTS,
            NodeTypeDataManager.TEXT_XML);
         readParamsFromRegistryService(sessionProvider);
         prepareRootNode(sessionProvider, rootNodePath);
      }
      catch (PathNotFoundException e)
      {
         try
         {
            readParamsFromFile();
            writeParamsToRegistryService(sessionProvider);

            prepareRootNode(sessionProvider, rootNodePath);
         }
         catch (RepositoryException exc)
         {
            LOG.error("Cannot write init configuration to RegistryService", exc);
         }
         catch (IOException exc)
         {
            LOG.error("Cannot write init configuration to RegistryService", exc);
         }
         catch (SAXException exc)
         {
            LOG.error("Cannot write init configuration to RegistryService", exc);
         }
         catch (ParserConfigurationException exc)
         {
            LOG.error("Cannot write init configuration to RegistryService", exc);
         }
      }
      catch (RepositoryException e)
      {
         LOG.error("Error while register nodetypes/checking existance", e);
      }
      finally
      {
         sessionProvider.close();
      }
   }
295683
public void start()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "start");

    if(!started)
    {
      started = true;
      if(keyGroup != null)
        keyGroup.startMember();
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "start");
  }
916954
public void start() {
		if (state.compareAndSet(UNKNOWN, STARTING)){
			log.debug("Starting...");
			if ( (StringUtils.isBlank(startSqlCondition) || isInCondition(startSqlCondition))
					&& (StringUtils.isBlank(startSqlConditionResource) || isInConditionResource(startSqlConditionResource))
					){
				if (StringUtils.isNotBlank(startSQL)){
					executeSQL(startSQL);
				} else if (StringUtils.isNotBlank(startSqlResource)){
					executeSqlResource(startSqlResource);
				}
			}
			state.set(RUNNING);
		}else{
			log.warn("Start request ignored. Current state is: " + stateNames[state.get()]);
		}
	}
1272444
void start() {
    final ContextStart contextStart = new ContextStartImpl(this.identifier);
    for (final EventHandler<ContextStart> startHandler : this.contextStartHandlers) {
      startHandler.onNext(contextStart);
    }
  }
98849
@Synchronized
  final void start(Optional<String> name) {
    if (!this.isStarted) {
      this.startImpl(name);
      this.isStarted = true;
    }
  }
896496
@Override
    public void start(boolean deliverImmediately)
                    throws SISessionUnavailableException, SISessionDroppedException,
                    SIErrorException
    {
        if (TraceComponent.isAnyTracingEnabled() && CoreSPIConsumerSession.tc.isEntryEnabled())
            SibTr.entry(CoreSPIConsumerSession.tc, "start",
                        new Object[] { this, Boolean.valueOf(deliverImmediately) });
        //start the LCP
        _localConsumerPoint.start(deliverImmediately);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(CoreSPIConsumerSession.tc, "start");
    }
1095062
void start(final Handler<OutputGroup> startHandler) {
    connection.doGroupStart(id, name, args, parent);
    this.startHandler = startHandler;
  }
88061
@Override
  public void start()
  {
    if (_lifecycle.isActive()) {
      return;
    }
    
    synchronized (_lifecycle) {
      if (! _lifecycle.toInit()) {
        return;
      }
      
      init(_stubMain);
    }
    
    start(_stubMain);
  }
801106
@Override
  public synchronized void start() {
    if (thread != null) {
      throw new IllegalThreadStateException("Parser already started");
    }

    String name = getThreadName() + "(" + getUri().toString() + ")";

    CountDownLatch startSignal = new CountDownLatch(1);
    Runnable runnable = getRunnable(startSignal);

    thread = new Thread(runnable, name);
    thread.start();

    // Block until the thread has started
    try {
      startSignal.await();
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    }
  }
877245
public void start() {
        if(actionInBackground != null) {

            Runnable jobToRun = new Runnable() {
                @Override
                public void run() {
                    result = (JobResult) actionInBackground.doAsync();
                    onResult();
                }
            };

            if(getExecutorService() != null) {
               asyncFutureTask = (FutureTask) getExecutorService().submit(jobToRun);
            } else {
                asyncThread = new Thread(jobToRun);
                asyncThread.start();
            }
        }
    }
176083
@Override
  public void start() {
    if (mIsRunning || mAnimationBackend == null || mAnimationBackend.getFrameCount() <= 1) {
      return;
    }
    mIsRunning = true;
    mStartTimeMs = now();
    mExpectedRenderTimeMs = mStartTimeMs;
    mLastFrameAnimationTimeMs = -1;
    mLastDrawnFrameNumber = -1;
    invalidateSelf();
    mAnimationListener.onAnimationStart(this);
  }
737110
public void start() {
        setState(STATE_RUNNING);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "Start: " + this);
        }
    }
1042606
public void start() {
        logger.info("----------------------------"); //$NON-NLS-1$
        logger.info(Messages.i18n.format("StorageImportDispatcher.StartingImport")); //$NON-NLS-1$

        policyDefIndex.clear();
        currentOrg = null;
        currentPlan = null;
        currentApi = null;
        currentClient = null;
        currentClientVersion = null;
        contracts.clear();
        apisToPublish.clear();
        clientsToRegister.clear();
        gatewayLinkCache.clear();

        try {
            this.storage.beginTx();
        } catch (StorageException e) {
            throw new RuntimeException(e);
        }
    }
762638
public void     start() throws Exception
    {
        log.debug("Starting");

        if ( !started.compareAndSet(false, true) )
        {
            IllegalStateException ise = new IllegalStateException("Already started");
            throw ise;
        }

        state.start();
    }
884287
public void start() {
		
		lock.lock();
		
		try {
			executorService = Executors.newSingleThreadScheduledExecutor();
			
			try {
				startUp();
			} catch (Throwable t) {
				LOGGER.info("Exception in service start up", t);
			}
			
			currentFuture = executorService.schedule(new RunOneIterationAndReschedule(), 0, TimeUnit.MILLISECONDS);
		} finally {
			lock.unlock();
		}
	}
362002
public void start() {
		System.out.println(new LogEntry("starting root console"));
		try {
			openFileReader();
		} catch (IOException ioe) {
			throw new ResourceException("can not open file reader", ioe);
		}
		thread = new Thread(this);
		isRunning = true;
		thread.start();
	}
652645
@LifecycleStart
  @Override
  public void start() throws Exception
  {
    super.start();

    synchronized (lifecycleLock) {
      Preconditions.checkState(!started, "already started");
      started = true;

      try {
        cleanupStaleAnnouncements();
        registerRunListener();
        pathChildrenCache.start();

        log.info("Started WorkerTaskMonitor.");
        started = true;
      }
      catch (InterruptedException e) {
        throw e;
      }
      catch (Exception e) {
        log.makeAlert(e, "Exception starting WorkerTaskMonitor")
           .emit();
        throw e;
      }
    }
  }