/*
(non-Javadoc)

@see com.nokia.dempsy.output.OutputExecuter#stop()
771137
@Override
    public void stop() {
        try {
            // gracefully shutting down
            scheduler.shutdown(false);
        } catch (final SchedulerException se) {
            LOGGER.error("Error occurred while stopping the cron scheduler : " + se.getMessage(), se);
        }
    }
466120
@CommandArgument
  public void stop() {
    System.out.println("Stopping worker");
    worker.shutdown();
    workerThread.interrupt();
    try {
      workerThread.join();
    } catch (InterruptedException e) {
      logger.warn("Joining to worker thread interrupted", e);
    }
    worker = null;
    workerThread = null;
    taskProgressStates = null;
  }
597912
public void stop() {
		if (this.writer != null) {
			this.writer.stop();
			this.writer.getLogRepositoryManager().stop();
			this.writer = null;
		}
	}
118235
public void stop() {
        if (mMonitorStarted) {
            mMonitorStarted = false;
            Looper.getMainLooper().setMessageLogging(null);
            mBlockCanaryCore.stackSampler.stop();
            mBlockCanaryCore.cpuSampler.stop();
        }
    }
950791
@Override
  public void stop() {
    if (cancellable != null) {
      cancellable.cancel();
      cancellable = null;
    }
    
    if (reader != null) {
      reader.close();
    }
    
    super.stop();
  }
919150
public void stop() {
      if(isStarted.compareAndSet(true, false)) {
         for(Reporter reporter : reporters) {
            reporter.stop();
         }
      }
   }
703916
public void stop() {
        hide();
        running = false;
        Closeables.closeQuitely(reader);
        Closeables.closeQuitely(in);
    }
384503
public void stop() {
        Plugin plugin = getPlugin();
        if (plugin != null) {
            try {
                LOGGER.log(Level.FINE, "Stopping {0}", shortName);
                plugin.stop();
            } catch (Throwable t) {
                LOGGER.log(WARNING, "Failed to shut down " + shortName, t);
            }
        } else {
            LOGGER.log(Level.FINE, "Could not find Plugin instance to stop for {0}", shortName);
        }
        // Work around a bug in commons-logging.
        // See http://www.szegedi.org/articles/memleak.html
        LogFactory.release(classLoader);
    }
1220805
@Override
    public synchronized void stop() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "Stopping the basic FFDC service");
        }
        logSummary(true);
    }
1056611
public void stop() {
        if (started) {
            stopped();
        }
        started = false;
        if (worker != null) {
            worker.cancel();
        }
        
        if(mediaSink!=null) {
        	mediaSink.stop();
        }
        	
        timestamp = 0;
    }
1086743
@Override
  public void stop() {
    cancellable.cancel();

    try {
      selector.close();
    } catch (Exception e) {
      logger().log("Failed to close selctor for " + name + " while stopping because: " + e.getMessage(), e);
    }
  }
874164
public static synchronized void stop(){
        if(status.equals("stopped"))
            return;
        long t = System.currentTimeMillis();

        startupUpdator.stop();
        messageListener.stop();

        fileExchange.stop();
        queueWorker.stop();

        status = "stopped";
        LOG.info("Cluster node "+nodeId+" stopped ("+(System.currentTimeMillis()-t)+" ms.)");
    }
1285257
public void stop() {
		if (this.logWriter != null) {
			this.logWriter.stop();
			this.logWriter.getLogRepositoryManager().stop();
			this.logWriter = null;
		}
		if (this.traceWriter != null) {
			this.traceWriter.stop();
			this.traceWriter.getLogRepositoryManager().stop();
			this.traceWriter = null;
		}
	}
737582
@Override
    public void stop(){
        if(isStarted){
            synchronized (this) {
                if (isStarted) {
                    if (getLookupService() instanceof Closable) {
                        ((Closable) getLookupService()).stop();
                    }
                    isStarted = false;
                }
            }
        }
    }
337249
@Override
    public synchronized boolean stop() {
        if (!this.isStarted()) {
            throw new IllegalStateException("Cannot terminate what was not started.");
        } else if (!this.isStopped.compareAndSet(false, true)) {
            return false;
        }
        DefaultLogWatch.LOGGER.info("Terminating {}.", this);
        this.tailing.stop();
        this.consumers.stop();
        this.handingDown.clear();
        this.storage.logWatchTerminated();
        DefaultLogWatch.LOGGER.info("Terminated {}.", this);
        return true;
    }
931985
public void stop() {
		resume();
		final Thread thread = _thread;
		if (thread != null) {
			thread.interrupt();
			try {
				thread.join();
			} catch (InterruptedException e) {
				Thread.currentThread().interrupt();
			} finally {
				_thread = null;
			}
		}
	}
257822
@Override public void stop() {
        lock.lock();
        try {
            if (process != null) {
                destroyProcess();
            }
            process = null;
        } finally {
            lock.unlock();
        }
    }