Start the timer.
<p/>
Creates the underlying {@code java.util.Timer} and its task-running daemon thread.
Following a successful call to {@code start()} subsequent calls are noops.
186669
public synchronized void start() {
        if (!running) {
            checkState(timer == null);

            timer = new java.util.Timer(true); // use daemon thread internally
            schedulePurging(); // schedule timeout to purge cancelled tasks from the timer task queue

            running = true;
        }
    }
186905
@Override
	public void start() {
		if (state.start()){
			try{
				doStart();
				state.finishStarting();
			}catch(Exception e){
				state.failStarting();
				logger.warn("Failed to start {}", this.getClass().getName(), e);
			}
		}

	}
356587
public void start() {
    	if(this.isActive)
    		return;
    	
        if (clock == null) {
            throw new IllegalStateException("Clock is not set");
        }

        this.isActive = true;
        
        logger.info("Starting ");
        
        coreThread.activate();
        criticalThread.activate();
        for(int i=0;i<workerThreads.length;i++)
        	workerThreads[i].activate();
        
        for(int i=0;i<criticalWorkerThreads.length;i++)
        	criticalWorkerThreads[i].activate();        
        
        logger.info("Started ");
    }
294902
def __thread_started(self):
		
		if self.__task is None:
			raise RuntimeError('Unable to start thread without "start" method call')
		self.__task.start()
		self.__task.start_event().wait(self.__scheduled_task_startup_timeout__)
231574
def start(self, threaded=True):
        
        self.running = True
        if threaded:
            self._thread = Thread(target=self._run)
            self._thread.start()
        else:
            self._run()
992241
def start(self) -> None:
        
        self.stop()  # stop an existing thread
        self._thread = receiverThread(socket=self.sock, callbacks=self._callbacks)
        self._thread.start()
94272
public TimeCounter start() {
        switch (state) {
            case UNSTARTED:
                watch.start();
                break;
            case RUNNING:
                throw new IllegalStateException("Already started. ");
            case STOPPED:
                watch.resume();
        }
        state = State.RUNNING;
        return this;
    }
519441
public void startTimer()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    	SibTr.entry(tc, "startTimer");
    btmLockManager.lockExclusive();
    try
    {
      //only start if currently stopped
      if (isStopped)
      {
        //set stopped to false
        isStopped = false;
        //iterate over the entries currently in the active list
        LinkedListEntry entry = (LinkedListEntry) activeEntries.getFirst();
        while(entry != null && activeEntries.contains(entry))
        {
          //start an alarm for each entry
          startNewAlarm(entry);
          entry = (LinkedListEntry) entry.getNext();
        }
      }
    }
    finally
    {
      btmLockManager.unlockExclusive();
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    	SibTr.exit(tc, "startTimer");
  }
890810
public void start(final Date start) {
		if (start != null) {
			counter.increment();
			timer.start(start);
		}
	}
891878
def start(self, daemon=True):
        
        if self._run_lock.acquire(False):
            try:
                # there is a short race window in which `start` release the lock,
                # but `run` has not picked it up yet, but the thread exists anyway
                if self._run_thread is None:
                    self._run_thread = threading.Thread(target=self._run_in_thread)
                    self._run_thread.daemon = daemon
                    self._run_thread.start()
            finally:
                self._run_lock.release()
916993
public void start() throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "start");

    synchronized (this)
    {
      active = true;
      // start the liveness timer for sending ControlRequestHighestGeneratedTick, if needed
      if (!completedTicksInitialized)
      {
        if (initRequestId == -1)
          initRequestId = parent.generateUniqueValue();
        requestHighestGeneratedTickTimer = new RequestHighestGeneratedTick();
        //we call the alarm directly
        requestHighestGeneratedTickTimer.alarm(null);
      }
      if (parent.getCardinalityOne() && !isFlushed)
      {
        inactivityTimer =
          am.create(
            mp.getCustomProperties().get_remote_consumer_cardinality_inactivity_interval(),
            inactivityHandler);
      }
      if (resetRequestAckSender != null)
      {
        boolean done = resetRequestAckSender.start();
        if (done)
          resetRequestAckSender = null;
      }
      // start all the liveness timers for value ticks
      dem.startTimer();
      if (imeRestorationHandler!=null)
        imeRestorationHandler.startTimer();
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "start");
  }
163714
def _start_new_timer(self):
        
        if not self._running.is_set():
            return False
        self._timer = self.timer_impl(
            interval=self._interval,
            function=self._check_for_life_signs
        )
        self._timer.daemon = True
        self._timer.start()
        return True
1120133
public Stopwatch start() {
        nanosStart = System.nanoTime();
        callable.call();
        ended = true;
        nanosEnd = System.nanoTime();
        return this;
    }
810279
public Timer createTimer()
   {
      Timer t = new Timer(true);

      if (timers == null)
         timers = new ArrayList<Timer>();

      timers.add(t);

      return t;
   }
535378
def _start_check_timer(self):
        
        if self.timer:
            self.timer.cancel()
        self.timer = threading.Timer(2.5, self.check_complete)
        self.timer.daemon = True
        self.timer.start()
360598
public Stopwatch start() {
        if (myTimerIsRunning) {
            throw new IllegalStateException(LOGGER.getI18n(MessageCodes.UTIL_040));
        }

        myStart = System.currentTimeMillis();
        myTimerIsRunning = true;

        return this;
    }
346410
def start(self):
        
        self._thread = t = threading.Thread(target=self._monitor)
        t.setDaemon(True)
        t.start()