Stops the monitor, no further updates will be reported.
547995
public void stopMonitor() {
        logger.info("Stopping Directory Update Monitor");
        try {
            monitor.stop();
        } catch (IllegalStateException e) {
            logger.info("File alteration monitor is already stopped: " + e.getMessage());
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }
428693
def stop(self) -> None:
        
        if not self._running:
            return

        self._running = False
        self._receiving_queue.put_nowait((TRANSPARENT_EVENT, None))
        self._internal_queue.put_nowait((TRANSPARENT_EVENT, None))
947079
void stop() {
    stopAsync();
    try {
      // stopperThread is not null for sure
      // join() does nothing if thread already finished
      stopperThread.join();
      lifecycle.tryToMoveTo(Lifecycle.State.STOPPED);
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    }
    exit.exit(0);
  }
403912
public synchronized void stop() {
        if (!monitorActive) {
            return;
        }
        monitorActive = false;
        resetAccounting(milliSecondFromNano());
        if (trafficShapingHandler != null) {
            trafficShapingHandler.doAccounting(this);
        }
        if (scheduledFuture != null) {
            scheduledFuture.cancel(true);
        }
    }
641536
public void stop() throws IOException {
		synchronized (this.monitor) {
			if (this.serverThread != null) {
				this.serverThread.close();
				try {
					this.serverThread.join(2000);
				}
				catch (InterruptedException ex) {
					Thread.currentThread().interrupt();
				}
				this.serverThread = null;
			}
		}
	}
991954
def stop(self):
        
        super(Multi, self).stop()
        self.monitor_thread.join()

        logging.info("Multi-plugin health monitor: Stopping plugins")
        for p in self.plugins:
            p.stop()

        logging.info("Multi-plugin health monitor: Stopped")
458085
public final void stop() {
        SystemException finalException = null;

        try {
            _interlock.await();
        } catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
        } finally {
            try {
                if (_unlocked) {
                    _log.info("Stopping {}.", getName());
                    doStop();
                }
            } catch (Exception ex) {
                finalException = new SystemException(ex);
            } finally {
                _started = false;
            }
        }
        if (finalException != null) {
            throw finalException;
        }
    }
420542
def _StopStatusUpdateThread(self):
    """"""
    self._status_update_active = False
    if self._status_update_thread.isAlive():
      self._status_update_thread.join()
    self._status_update_thread = None
377797
def stop(self):
        
        if self._thread is not None and self._thread.isAlive():
            self._done.set()
566620
public void stop()
    {
        if (mCamera != null)
        {
            mCamera.startPreview();
            mCamera.release();
            mCamera = null;
            mTryOpenCamera = false;
            onStop();
        }
    }
56339
public void stop() {
    if (runnerThread == null) {
      return;
    }

    runnerThread.interrupt();

    nsLock.writeLock().lock();
    try {
      if (runnerThread == null) {
        return;
      }

      this.cancel();
      this.close();

      while (runnerThread.isAlive()) {
        runnerThread.interrupt();
        try {
          runnerThread.join(1000);
        } catch (final Exception e) {
          e.printStackTrace();
          return;
        }
      }
      runnerThread = null;
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      nsLock.writeLock().unlock();
    }
  }
359261
def stop(self):
        
        if self.interval is not None:
            self._queue.put_nowait(None)
            self._thread.join()
            self.interval = None
1168788
public synchronized void stop()
  {
    running.set(false);
    if(thread.isAlive()) {
      thread.interrupt();
      wait(this, STOP_TIMEOUT);
    }
  }
1018352
def kill_monitor(self, check_alive=True):
        
        self._kill_process_type(
            ray_constants.PROCESS_TYPE_MONITOR, check_alive=check_alive)
1340176
public void stop() {
    if (server == null) {
      return;
    }

    logger.fine("Shutting down STP connection listener");
    monitor.remove(server);
    try {
      server.close();
    } catch (IOException e) {
      // ignored
    } finally {
      server = null;
    }
  }
50208
@LifecycleStop
  public void stop()
  {
    giant.lock();

    try {
      tasks.clear();
      taskFutures.clear();
      active = false;
      managerExec.shutdownNow();
      storageSyncExec.shutdownNow();
      managementMayBeNecessary.signalAll();
    }
    finally {
      giant.unlock();
    }
  }
341943
def stop(self):
        
        if self.socket is not None:
            self.socket.close()
            self.socket = None
            self.data = None