Start the timer.  If `duration` is not None, it should
        specify the time to expiration in seconds.
496280
def start(self, duration=None):
        
        if duration is None:
            duration = self.duration

        self.set(duration)
1233179
def timer_on (opts={})
    @timer.cancel unless @timer.nil?
    length = @timeout + (opts[:with_interval] ? @interval : 0)
    @timer = EventMachine::Timer.new(length) {
      scrap = @buf ? " - #{@buf.flush}" : ''
      @handler.logger.error "timeout on #{@handler.name}" + scrap
      @handler.logger.debug {"pid #{get_pid}"}
      close_connection()
    }
  end
199498
function Timer (timer, startTime) {
  this._timer = timer ? timer._timer : microtime()
  this.start = startTime >= 0 ? startTime * 1000 : this._timer() // microsecond integer
  this.duration = null // millisecond float
}
657176
def start(self):
        
        if self._timer.isActive():
            return

        self._starttime = datetime.datetime.now()
        self._timer.start()
1047050
def set_timeout(self, timeout, callback):
        """"""
        if not self._ready_sem.acquire(False):
            raise Scapy_Exception("Timer was already started")

        self._callback = callback
        self._timeout = timeout
        self._cancelled.clear()
        self._busy_sem.release()
776483
function start(): void {
        if($this->nativeHrtime) {
            $this->timer = \hrtime(true);
        } elseif($this->hrtime) {
            $this->timer->start();
        } else {
            $this->timer = \microtime(true);
        }
    }
1219606
def timer_cb(self, timer):
        """"""
        dt_now = datetime.utcnow().replace(tzinfo=pytz.utc)
        self.logger.debug("timer fired. utc time is '%s'" % (str(dt_now)))

        for clock in self.clocks.values():
            clock.update_clock(dt_now)

        # update clocks approx every second
        timer.start(1.0)
920542
def start(self, timeout=None):
        """"""

        self.thread.start()
        start_time = time.time()
        if not timeout:
            timeout = self.timeout
        # every second, check the condition of the thread and return
        # control to the user if appropriate
        while start_time + timeout > time.time():
            self.thread.join(1)
            if self.started:
                return True
            if self.error:
                return False
        return False
34946
def start(self, timeout=None):
        
        if self._handler_thread and self._handler_thread.isAlive():
            raise RuntimeError('Message handler thread already started')
        self._server.start(timeout)
        self.ioloop = self._server.ioloop
        if self._handler_thread:
            self._handler_thread.set_ioloop(self.ioloop)
            self._handler_thread.start(timeout)
474183
def on_expiration(self, session, ese=None, session_key=None):
        
        super().on_expiration(session, ese, session_key)
        self.on_invalidation(session_key)
515810
def start_timer(self, reprate):
        """"""
        print 'starting digital output at rate {} Hz'.format(reprate)
        self.trigger_task = DigitalOutTask(self.trigger_src, reprate)
        self.trigger_task.start()
1301368
def start(self):
        
        if not self._start:
            self._first_start = time.perf_counter()
            self._start = self._first_start
        else:
            self._start = time.perf_counter()
74499
def run(self):
        

        self.__timer = QTimer()
        self.__timer.moveToThread(self)
        self.__timer.start(Constants.default_timer_cycle * self.__timer_cycle_multiplier)

        self.__timer.timeout.connect(self.__watch_file_system, Qt.DirectConnection)

        self.exec_()
948923
private synchronized void startTimer() {
    if (timer == null) {
      timer = new Timer("Timer thread for monitoring " + getContextName(), 
                        true);
      TimerTask task = new TimerTask() {
          public void run() {
            try {
              timerEvent();
            }
            catch (IOException ioe) {
              ioe.printStackTrace();
            }
          }
        };
      long millis = period * 1000;
      timer.scheduleAtFixedRate(task, millis, millis);
    }
  }
692457
public void start() {
    	if(logger.isDebugEnabled()) {
            logger.debug("start");
        }
        started.set(true);
        if(logger.isDebugEnabled()) {
            logger.debug("Started proxy timer service "+ this);
        }
    }
201207
def __start_timer(self, delay):
        
        self.__timer = threading.Timer(delay, self.__reconnect)
        self.__timer.daemon = True
        self.__timer.start()
1313948
def init_timer(client_id):
    
    if client_id in timers and timers[client_id]:
        timers[client_id].start()
        return
    # Create a timer to call check_new_message function after every 2 seconds.
    # client_id param is needed to be passed to check_new_message
    timers[client_id] = RepeatedTimer(2, check_new_messages, client_id)