/* (non-Javadoc)
@see org.mobicents.servlet.sip.core.timers.ProxyTimerService#stop()
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);
        }
    }
1220805
@Override
    public synchronized void stop() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "Stopping the basic FFDC service");
        }
        logSummary(true);
    }
1223192
@Override
  public boolean stop()
  {
    if (! _lifecycle.toStopping())
      return false;

    log.finest(this + " stopping");

    closeConnections();

    destroy();

    return true;
  }
373879
public synchronized void stop() {
        if (isRunning()) {
            socket.get().close();
            socket.set(null);
            deliverLifecycleAnnouncement(logger, false);
        }
    }
1150399
@Override
    public void stop(long millisec) throws ChannelException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "Stop channel: " + this + " time=" + millisec);
        }
        if (0L < millisec) {
            this.quiescing = true;
            if (0 == this.activeConnections.get()) {
                // no current connections, notify the final stop can happen now
                signalNoConnections();
            }
        } else {
            this.quiescing = false;
            stop0Called = true;
        }
    }
318525
@Override
	public void stop()
	{
		if (!started)
			return;
		
		log.info("Stopping listener ["+getName()+"]");
		
		// Close the listen socket
		multiplexer.unregisterServerSocketHandler(this);
		multiplexer.stop();
		multiplexer = null;
		
		// Close remaining clients
		closeRemainingClients();
		
		started = false;
	}
487701
public synchronized void stop() {
		LOG.debug("Stopping server on " + port);
		running = false;
		if (handlers != null) {
			for (int i = 0; i < handlerCount; i++) {
				if (handlers[i] != null) {
					handlers[i].interrupt();
				}
			}
		}
		listener.interrupt();
		listener.doStop();
		responder.interrupt();
		notifyAll();

		// Wait until shut down of handlers is complete
		if (this.handlers != null) {

			while (true) {

				int i = 0;
				for (; i < this.handlerCount; i++) {
					if (this.handlers[i] != null) {
						if (!this.handlers[i].isShutDown()) {
							break;
						}
					}
				}

				if (i < this.handlerCount) {
					try {
						wait(100);
					} catch (InterruptedException e) {
						break;
					}
				} else {
					// exit while loop
					break;
				}
			}
		}

		// Wait until shut down of responder is complete
		while (!this.responder.isShutDown()) {
			try {
				wait(100);
			} catch (InterruptedException e) {
				break;
			}
		}

		// Wait until shut down of listener is complete
		while (!this.listener.isShutDown()) {
			try {
				wait(100);
			} catch (InterruptedException e) {
				break;
			}
		}
	}
876905
@Override
  public void stop() {
    logger().log("Server stopping...");

    failTimedOutMissingContentRequests();

    channel.stop();
    channel.close();

    for (final Dispatcher dispatcher : dispatcherPool) {
      dispatcher.stop();
    }

    logger().log("Server stopped.");

    super.stop();
  }
1158042
public void stop() {
		hits = 0;
		misses = 0;
		unavailable = 0;
		delayedHits = 0;
		delayedMisses = 0;
		data.clear();
		mirror.clear();
		isStarted = false;
	}
1072992
@Override
    public void stop() {
        if(isStarted.compareAndSet(true,false)){
            ScheduledExecutorService healthCheck = healthCheckService.getAndSet(newHealthCheckService());
            healthCheck.shutdown();
            LOGGER.info("the SD API RegistryHealth Check Task has stopped.");
            ScheduledExecutorService heartbeat = heartbeatService.getAndSet(newHeartbeatService());
            heartbeat.shutdown();
            LOGGER.info("the SD API Heartbeat Task has stopped.");
        }
    }
604214
@Override
  public void stop(final Throwable exception) {

    LOG.entering(CLASS_NAME, "stop");

    synchronized (this.schedule) {

      if (this.isClosed) {
        LOG.log(Level.FINEST, "Clock has already been closed");
        return;
      }

      this.isClosed = true;
      this.exceptionCausedStop = exception;

      final Time stopEvent = new StopTime(this.timer.getCurrent());
      LOG.log(Level.FINE,
          "Stop scheduled immediately: {0} Outstanding client alarms: {1}",
          new Object[] {stopEvent, this.numClientAlarms});

      assert this.numClientAlarms >= 0;
      this.numClientAlarms = 0;

      this.schedule.clear();
      this.schedule.add(stopEvent);
      this.schedule.notify();
    }

    LOG.exiting(CLASS_NAME, "stop");
  }
739376
public void stop()
	{
		try
		{
			stopping = true;
			myServerSocket.close();
			myThread.join();
		}
		catch ( IOException | InterruptedException e ) {
			logger.log(Level.WARNING, "Had unexpected exception during stop", e);
		}
	}
1248658
public Stopwatch stop() {
        if (!myTimerIsRunning) {
            throw new IllegalStateException(LOGGER.getI18n(MessageCodes.UTIL_041));
        }

        myStop = System.currentTimeMillis();
        myTimerIsRunning = false;

        return this;
    }
676451
public synchronized void stop() {
        if (isRunning()) {
            running.set(false);
            DeviceFinder.getInstance().removeDeviceAnnouncementListener(announcementListener);
            dbServerPorts.clear();
            for (Client client : openClients.values()) {
                try {
                    client.close();
                } catch (Exception e) {
                    logger.warn("Problem closing " + client + " when stopping", e);
                }
            }
            openClients.clear();
            useCounts.clear();
            deliverLifecycleAnnouncement(logger, false);
        }
    }
315813
public synchronized void stop() {
        if (scheduledFuture != null) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                Tr.event(this, tc, "Scan task cancelled");
            }
            scheduledFuture.cancel(false);
            scheduledFuture = null;
        }
    }
823628
public final void stop()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "stop");

        synchronized (alarmLock)
        {
            if (enabled)
            {
                loaderStopTime = timeNow();
                enabled = false;
                shutdown = true;
            }
            if (loaderAlarm != null)
            {
                loaderAlarm.cancel();
                loaderAlarm = null;
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "stop");
    }
1146858
public void stop() throws Throwable
   {
      Context context = new InitialContext();

      context.unbind(JNDI_NAME);

      context.close();
   }