Stop LongPolling thread
		
		:return: none
181935
def stopLongPolling(self):
		'''
		
		'''
		if(self.longPollThread.isAlive()):
			self._stopLongPolling.set()
			self.log.debug("set stop longpolling flag")
		else:
			self.log.warn("LongPolling thread already stopped")
		return
924023
def __stopOpenThread(self):
        
        print 'call stopOpenThread'
        try:
            if self.__sendCommand('thread stop')[0] == 'Done':
                return self.__sendCommand('ifconfig down')[0] == 'Done'
            else:
                return False
        except Exception, e:
            ModuleHelper.WriteIntoDebugLogger("stopOpenThread() Error: " + str(e))
1369047
def stop(self):
        
        for run_event in self.run_events:
            run_event.clear()

        for thread in self.thread_pool:
            thread.join()
371710
def stop(self, timeout = 10.0):
		
		if (self._send_greenlet is not None) and \
				(self._send_queue.qsize() > 0):
			self.wait_send(timeout = timeout)

		if self._send_greenlet is not None:
			gevent.kill(self._send_greenlet)
			self._send_greenlet = None
		if self._error_greenlet is not None:
			gevent.kill(self._error_greenlet)
			self._error_greenlet = None
		if self._feedback_greenlet is not None:
			gevent.kill(self._feedback_greenlet)
			self._feedback_greenlet = None

		return self._send_queue.qsize() < 1
882844
def stop(self, timeout=None):
        
        with self._lock:
            if self._thread:
                self._queue.put_nowait(self._terminator)
                self._thread.join(timeout=timeout)
                self._thread = None
                self._thread_for_pid = None
158538
def stop(self, timeout=15):
        
        pp = self.pid
        if pp:
            try:
                kill_process_nicely(pp, timeout=timeout)
            except psutil.NoSuchProcess:
                pass
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")
817860
def interrupt(self, threadId=None):
        
        back = self.backend()
        if back:
            back.interrupt(threadId)
876069
def stop(self):
        """"""

        if self._started is False:
            raise ArgumentError("EmulationLoop.stop() called without calling start()")

        self.verify_calling_thread(False, "Cannot call EmulationLoop.stop() from inside the event loop")

        if self._thread.is_alive():
            self._loop.call_soon_threadsafe(self._loop.create_task, self._clean_shutdown())
            self._thread.join()
271370
def stop(self):
		
		thread = self.thread()
		if thread is not None:
			if self.stop_event() is not None:
				self.stop_event().set()

			self.thread_stopped()

			if self.stop_event() is not None:
				thread.join(self.join_timeout())
				self.close_thread()
1200350
def stop(self):
        """"""
        self.keep_listening = False
        # if threaded, kill threads before going down
        if hasattr(self, 'join'):
            self.join()
        self.log("Went down.")
        return True
1150940
public Void longPollLoop() throws JoynrShutdownException {
        logger.debug("LongPollingChannel OPENING CHANNEL: {} ", id);
        try {
            while (true) {
                // start long poll if it has not been disabled.
                // Checking the disable switch and request creation has
                // to be an atomic process.
                // When the request creation is done it can be canceled
                // by a call to suspend.
                if (shutdown) {
                    throw new JoynrShutdownException("shutting down");
                }

                if (longPollingDisabled == true) {
                    try {
                        statusLock.lockInterruptibly();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        throw new JoynrShutdownException("INTERRUPTED. Shutting down");
                    }
                    logger.trace("Waiting for long polling to be resumed.");
                    statusChanged.awaitUninterruptibly();

                } else {
                    longPoll();
                    try {

                        // prevent error when long polling connection was reestablished too soon after repsone being
                        // returned
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        throw new JoynrShutdownException("INTERRUPTED. Shutting down");
                    }
                }

            }
        } finally {
            // shutdown();
            logger.info("LongPollingChannel CHANNEL: " + id + " long poll loop exited");
        }
    }
1106330
def stop(self, timeout=1.0):
        
        if timeout:
            self._running.wait(timeout)
        self._running.clear()
        # Make sure to wake the run thread.
        self._wake.set()
1103132
def stop(self, timeout=5):
        
        self.inner().stop(timeout=timeout)
        self.inner().reload()
359261
def stop(self):
        
        if self.interval is not None:
            self._queue.put_nowait(None)
            self._thread.join()
            self.interval = None
258346
def halt(self):
        
        if self._callback:
            self._thread_continue = False
            self._thread.join()
181549
def disable(self, threads=True):
        
        if self.enabled_start:
            sys.settrace(None)
            self._disable()
        else:
            warn('Duplicate "disable" call')