Stop the timer without executing the callback.
11979
def cancel(self):
        """"""
        self._cancelled.set()
        if not self._dead:
            self._ready_sem.acquire()
            self._ready_sem.release()
545169
private void cancelAppendTimer() {
    if (appendTimer != null) {
      LOGGER.trace("{} - Cancelling append timer", context.getCluster().member().address());
      appendTimer.cancel();
    }
  }
164577
public void stop() {
    	if(logger.isDebugEnabled()) {
            logger.debug("stop");
        }
        started.set(false);
        super.cancel();
        if(logger.isDebugEnabled()) {
            logger.debug("Stopped proxy timer service "+ this);
        }
    }
1249237
def cancel(self):
        """"""
        if self.__process.is_alive():
            self.__process.terminate()

        _raise_exception(self.__timeout_exception, self.__exception_message)
1018661
public function stop()
    {
        if ($this->stopTimer) {
            $this->eventLoop->cancelTimer($this->stopTimer);
            $this->stopTimer = null;
        }

        $this->eventLoop->stop();
    }
258346
def halt(self):
        
        if self._callback:
            self._thread_continue = False
            self._thread.join()
907015
def resetTimeout(self):
        """"""
        if self.__timeoutCall is not None and self.timeOut is not None:
            self.__timeoutCall.reset(self.timeOut)
1315961
def stop(self):
    
    with self.lock:
      self.halting = True
      self.go.clear()
106
def stop(cls, name):
        
        cls.timer_end[name] = time.time()
        if cls.debug:
            print("Timer", name, "stopped ...")
18000
function stopTimeout(ctx) {
  assert(ctx);
  if (ctx.timer != null) {
    clearTimeout(ctx.timer);
    ctx.timer = null;
  }
  ctx.stopped = true;
}
436541
async def stop(self):
        """"""

        if self._rpc_task is not None:
            self._rpc_task.cancel()

        try:
            await self._rpc_task
        except asyncio.CancelledError:
            pass

        self._rpc_task = None
541033
def Stop(self):
    """"""
    self._Close()

    if self._rpc_thread.isAlive():
      self._rpc_thread.join()
    self._rpc_thread = None
727637
def stop(self) -> None:
        
        if self.is_running:
            if _logger is not None:
                self._log(INFO, "stop", __now=self.now())
            self._is_running = False
673900
def stop(self):
        
        self._lock.acquire()
        try:
            # Stop the timer
            if self._timer != None:
                self._timer.stop()
                self._timer = None
            
            # Unset started flag
            self.started = False
        finally:
            self._lock.release()
893500
def stop_listener(self):
        ''''''
        if self.sock is not None:
            self.sock.close()
            self.sock = None
        self.tracks = {}
545732
def off(  # pylint: disable=keyword-arg-before-vararg
            self, event: str = None, *handlers: T.Callable
    ) -> None:
        """"""

        if not event:
            self._events.clear()
            return

        if event not in self._events:
            raise EventNotFound(event)

        if not handlers:
            self._events.pop(event)
            return

        for callback in handlers:
            if callback not in self._events[event]:
                raise HandlerNotFound(event, callback)
            while callback in self._events[event]:
                self._events[event].remove(callback)
        return
235334
def stop(label, at=None, remove_from_labels=False, stop_once=True):
    """"""
    t = at if at is not None else time.time()

    if label not in labels:
        return None

    timer = Marker().loads(labels[label])

    if timer.is_running() or (timer.is_stopped() and not stop_once):
        timer.stop(t)

    if remove_from_labels:
        del labels[label]
    else:
        labels[label] = timer.dumps()

    return timer.duration()