Stop processing requests. Stops any passive or active components started in the <code>start</code>
method.
160650
public void stop() {
        if(log.isInfoEnabled()) {
            log.info("Stopping Zabbix agent.");
        }

        if(enablePassive) {
        	if(log.isInfoEnabled()) {
        		log.info("Stopping passive listener.");
        	}

	        listenerThread.shutdown();
	        try {
	            listenerThread.join();

	        } catch(InterruptedException ie) {
	            //
	        }

	        if(log.isInfoEnabled()) {
	        	log.info("Passive listener stopped.");
	        }
        }

        if(enableActive) {
        	if(log.isInfoEnabled()) {
        		log.info("Stopping active agent.");
        	}

        	activeThread.shutdown();
        	try {
        		activeThread.join();

        	} catch(InterruptedException ie) {
        		//
        	}

        	if(log.isInfoEnabled()) {
        		log.info("Active agent stopped.");
        	}
        }

        if(log.isInfoEnabled()) {
            log.info("Zabbix agent stopped.");
        }
    }
867334
def stop(self):
        """"""
        self._response['shouldEndSession'] = True
        self._response['action']['audio']['interface'] = 'stop'
        self._response['action']['audio']['sources'] = []
        return self
897202
@Override
    public void stop(){
        if (isStarted.compareAndSet(true,false)) {
            this.syncService.shutdown();
            getCache().clear();
            getMetadataKeyCache().clear();
        }
    }
1214489
@Override
    public void stop() {
        engine.stop();
        onPause();
        queueEvent(new Runnable() {
            @Override
            public void run() {
                renderer.recycle();
            }
        });
    }
641502
@TaskAction
  public void stopAction() {
    DevServer server =
        devServers.newDevAppServer(CloudSdkOperations.getDefaultHandler(getLogger()));
    try {
      server.stop(runConfig.toStopConfiguration());
    } catch (AppEngineException ex) {
      getLogger().error("Failed to stop server: " + ex.getMessage());
    }
  }
1114368
synchronized public void stop() {
    process = false;
    BlockEncodeRequest temp = new BlockEncodeRequest();
    temp.setAll(null, -1, -1, -1, -1, null);
    int count = frameThreadMap.size();
    for(int i = 0; i < count; i++) {
      unassignedEncodeRequests.add(temp);
    }
  }
1129885
public void stop() throws Exception {

		if( this.nazgulAgentFactory != null ) {
			for( ComponentInstance nazgul : this.nazgulAgentFactory.getInstances())
				deleteIPojoInstance( nazgul );
		}

		if( this.standardAgentFactory != null ) {
			for( ComponentInstance agent : this.standardAgentFactory.getInstances())
				deleteIPojoInstance( agent );
		}
	}
892221
public void stopping()
    {
        for (KernelExtension kernelExtension : kernelExtensions.keySet())
        {
            kernelExtension.stopping(kernelExtensions.get(kernelExtension));
        }
    }
1091676
def stop(self):
        

        instance_status = Instance.InstanceStatus(status='Terminated')
        xml_content = instance_status.serialize()

        headers = {'Content-Type': 'application/xml'}
        self._client.put(self.resource(), xml_content, headers=headers)
388817
@Override
  public void stop() {
    if (!mIsRunning) {
      return;
    }
    mIsRunning = false;
    mStartTimeMs = 0;
    mExpectedRenderTimeMs = mStartTimeMs;
    mLastFrameAnimationTimeMs = -1;
    mLastDrawnFrameNumber = -1;
    unscheduleSelf(mInvalidateRunnable);
    mAnimationListener.onAnimationStop(this);
  }
1018757
private void stop() {
        //unregister and free all resources;
        if (updateTask != null)
            updateTask.cancel();
        for (GenericStatsProducer producer : producers) {
            producer.genericStats.destroy();
            ProducerRegistryFactory.getProducerRegistryInstance().unregisterProducer(producer);
        }
        producers.clear();
    }
1164441
public void stop()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "stop");
    
    try
    {    
      _lockManager.lockExclusive();

      // Flag that we are in a started state. 
      _started = false;
    }      
    finally
    {
      _lockManager.unlockExclusive();
    }
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "stop");    
  }
886636
public synchronized void stop() throws Exception {
        if (!running) {
            return;
        }

        for (Connector each : this.connectors) {
            try {
                each.stop();
                each.setServer( null );
            } catch (Exception e) {
                // ignore
            }
        }

        running = false;
    }
403912
public synchronized void stop() {
        if (!monitorActive) {
            return;
        }
        monitorActive = false;
        resetAccounting(milliSecondFromNano());
        if (trafficShapingHandler != null) {
            trafficShapingHandler.doAccounting(this);
        }
        if (scheduledFuture != null) {
            scheduledFuture.cancel(true);
        }
    }
609878
@Stop
   public void stop() {
      if (needToUnregister) {
         // Only unregister the non cache MBean so that it can be restarted
         try {
            unregisterMBeans(nonCacheDMBeans);
            needToUnregister = false;
         } catch (Exception e) {
            log.problemsUnregisteringMBeans(e);
         }
      }

      // If removing cache, also remove cache MBean
      if (unregisterCacheMBean)
         globalJmxRegistration.unregisterCacheMBean(this.cacheName, this.cacheConfiguration
            .clustering().cacheModeString());

      // make sure we don't set cache to null, in case it needs to be restarted via JMX.
   }
1010359
public void stop() {

    this.stop = true;

    if (this.thread != null && this.thread.isAlive()) {
      this.thread.interrupt();

      for (TrackerClient client : this.clients.values()) {
        client.close();
      }

      try {
        this.thread.join();
      } catch (InterruptedException ie) {
        // Ignore
      }
    }
    this.myPeers.clear();

    this.thread = null;
  }
257822
@Override public void stop() {
        lock.lock();
        try {
            if (process != null) {
                destroyProcess();
            }
            process = null;
        } finally {
            lock.unlock();
        }
    }