Shutdown zmq listener.
4654
def stop(self):
        '''
        
        '''
        log.info('Stopping the zmq listener class')
        self.sub.close()
        self.ctx.term()
170870
public void shutdown(){
        transactionListenerSet.forEach(transactionListener -> transactionListener.close(null));
        transactionListenerSet.clear();
        openSessions.values().forEach(SessionImpl::close);
    }
1108601
def stop_listener_thread(self):
        
        if self.sync_thread:
            self.should_listen = False
            self.sync_thread.join()
            self.sync_thread = None
1330659
public synchronized void stop() {
        if (listenerThreads.size() > 0) {
            for (MulticastSocketListenerThread thread : listenerThreads) {
                thread.shutdown();
            }
        }

        listenerThreads.clear();
    }
471935
public void shutdown()
    {
        logger.info("Waiting for messaging service to quiesce");
        // We may need to schedule hints on the mutation stage, so it's erroneous to shut down the mutation stage first
        assert !StageManager.getStage(Stage.MUTATION).isShutdown();

        // the important part
        callbacks.shutdownBlocking();

        // attempt to humor tests that try to stop and restart MS
        try
        {
            for (SocketThread th : socketThreads)
                th.close();
        }
        catch (IOException e)
        {
            throw new IOError(e);
        }
    }
534787
public void shutdown() {
		singleton = null;
		log.info("Shuting down GossipMonger");
		isShutdown.set(true);
		threadPool.shutdown(); // Disable new tasks from being submitted
		// TODO: Wait for messages to end processing
		shutdownAndAwaitTermination(threadPool);
		// Clean ThreadLocal
		ref.remove();
	}
686532
def terminate(self):
        """"""
        logger.info(__(
            "Terminating Resolwe listener on channel '{}'.",
            state.MANAGER_EXECUTOR_CHANNELS.queue
        ))
        self._should_stop = True
1278971
public void stopListenting() {
        if (channel != null) {
            log.info("closing server channel");
            channel.close().syncUninterruptibly();
            channel = null;
        }
    }
358896
def stop(self):
        """"""
        if self.zap_socket:
            self.log.debug(
                'Stopping ZAP at {}'.format(self.zap_socket.LAST_ENDPOINT))
            super().stop()
1321590
def shutdown(self):
        """"""
        self._must_shutdown = True
        self._is_shutdown.wait()
        self._meta_runner.stop()
116713
def close(self) -> None:
        
        self.__data_channel_buffer.stop()
        self.__data_channel_buffer.close()
        self.__data_channel_buffer = None
        if not self.__was_playing:
            self.__hardware_source.stop_playing()
805102
public void shutdown() {
        if (zombie) {
            return;
        }
        logger.info("Shutting down Rythm Engine: [%s]", id());
        if (null != _cacheService) {
            try {
                _cacheService.shutdown();
            } catch (Exception e) {
                logger.error(e, "Error shutdown cache service");
            }
        }
        if (null != _secureExecutor) {
            try {
                _secureExecutor.shutdown();
            } catch (Exception e) {
                logger.error(e, "Error shutdown secure executor");
            }
        }
        if (null != _resourceManager) {
            try {
                _resourceManager.shutdown();
            } catch (Exception e) {
                logger.error(e, "Error shutdown resource manager");
            }
        }
        if (null != shutdownListener) {
            try {
                shutdownListener.onShutdown();
            } catch (Exception e) {
                logger.error(e, "Error execute shutdown listener");
            }
        }
        if (null != nonExistsTemplatesChecker) {
            nonExistsTemplatesChecker.onShutdown();
        }
        if (null != _templates) _templates.clear();
        if (null != _classes) _classes.clear();
        if (null != _nonExistsTags) _nonExistsTags.clear();
        if (null != nonExistsTemplates) nonExistsTemplates.clear();
        if (null != _nonTmpls) _nonTmpls.clear();
        _classLoader = null;
        Rythm.RenderTime.clear();
        zombie = true;
    }
996496
def close(self):
        
        self.log.info("Shutting down queue manager.")
        if hasattr(self.store, 'close'):
            self.store.close()

        if hasattr(self.subscriber_scheduler, 'close'):
            self.subscriber_scheduler.close()

        if hasattr(self.queue_scheduler, 'close'):
            self.queue_scheduler.close()
219802
private void shutdown(){
    parent.workerThreads.get(plan).remove(this);
    if (zk != null) {
      try {
        logger.debug("closing " + zk.getSessionId());
        zk.close();
        zk = null;
      } catch (InterruptedException e1) {
        logger.debug(e1);
      }
      logger.debug("shutdown complete");
    }
  }
572812
def shutdown(self):
        """"""
        self.stop_all_periodic_tasks()
        for channel in self._bcm_sockets:
            log.debug("Closing bcm socket for channel {}".format(channel))
            bcm_socket = self._bcm_sockets[channel]
            bcm_socket.close()
        log.debug("Closing raw can socket")
        self.socket.close()
541033
def Stop(self):
    """"""
    self._Close()

    if self._rpc_thread.isAlive():
      self._rpc_thread.join()
    self._rpc_thread = None
1232263
def stop(self):
        """"""
        if not self._dead:
            self._killed = True
            self._cancelled.set()
            self._busy_sem.release()
            self.join()
            if not self._ready_sem.acquire(False):
                warning("ISOTP Timer thread may not have stopped "
                        "correctly")