Joins thread, stops it from running
519330
def join(self):
        
        self.can_run = False
        super(Connector, self).join()
        for dm in self.doc_managers:
            dm.stop()
799178
def stop(self):
        """"""
        if self._progressing:
            self._progressing = False
            self._thread.join()
1177264
def join(self):
		
		self.inputfeeder_thread.join()
		self.pool.join()
		self.resulttracker_thread.join()
		self.failuretracker_thread.join()
452881
def stop(self):
        
        self._running = False
        if self._self_thread is not None:
            self._self_thread.cancel()
            self._self_thread = None
359261
def stop(self):
        
        if self.interval is not None:
            self._queue.put_nowait(None)
            self._thread.join()
            self.interval = None
947079
void stop() {
    stopAsync();
    try {
      // stopperThread is not null for sure
      // join() does nothing if thread already finished
      stopperThread.join();
      lifecycle.tryToMoveTo(Lifecycle.State.STOPPED);
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    }
    exit.exit(0);
  }
539648
def join(self, timeout=None):
        """"""
        Thread.join(self, timeout=timeout)
        if self.exc:
            msg = "Thread '%s' threw an exception `%s`: %s" \
                  % (self.getName(), self.exc[0].__name__, self.exc[1])
            new_exc = LaneExecutionError(msg)

            if PY3:
                raise new_exc.with_traceback(self.exc[2])  # pylint: disable=no-member
            else:
                raise (new_exc.__class__, new_exc, self.exc[2])
389517
def remove_stopped_threads (self):
        """"""
        self.threads = [t for t in self.threads if t.is_alive()]
377797
def stop(self):
        
        if self._thread is not None and self._thread.isAlive():
            self._done.set()
1108601
def stop_listener_thread(self):
        
        if self.sync_thread:
            self.should_listen = False
            self.sync_thread.join()
            self.sync_thread = None
1025700
def _try_join_cancelled_thread(thread):
    """"""
    thread.join(10)
    if thread.is_alive():
        logging.warning("Thread %s did not terminate within grace period after cancellation",
                        thread.name)
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
119806
private void joinAllThreads() {
        Iterator iter = registeredWachdogs.values().iterator();
        while (iter.hasNext()) {
            Watchdog th = (Watchdog) iter.next();
            boolean isJoining = true;
            if (!th.isAlive() && log.isDebugEnabled()) {
                log.debug("Thread " + th + " finished");
            }
            while (th.isAlive() && isJoining) {
                try {
                    th.getThread().join();
                    isJoining = false;
                    if (log.isDebugEnabled()) {
                        log.debug("Thread " + th + " joined and finished");
                    }
                } catch (InterruptedException e) {
                }
            }
        }
    }
1241341
def thread_stopped(self):
		
		task = self.task()
		if isinstance(task, WStoppableTask) is True:
			task.stop()
105332
public void stopThreads()
    {
        if (threadMap.isEmpty())
        {
            throw new IllegalStateException("threads are already interrupted");
        }
        lock.lock();
        try
        {
            Thread currentThread = Thread.currentThread();
            for (Thread thread : threadMap.values())
            {
                if (!currentThread.equals(thread))
                {
                    thread.interrupt();
                }
            }
            threadMap.clear();
            semaphoreMap.clear();
        }
        finally
        {
            lock.unlock();
        }
    }
189130
def wait_and_join(self, task):
        
        while not task.has_started:
            time.sleep(self._polling_time)
        task.thread.join()
1210628
def _close_thread(self, thread, thread_name):
        
        if thread is not None and thread.isAlive():
            self.logger.debug("Waiting for {} thread to close".format(thread_name))
            thread.join(timeout=self.settings['DAEMON_THREAD_JOIN_TIMEOUT'])
            if thread.isAlive():
                self.logger.warn("{} daemon thread unable to be shutdown"
                                 " within timeout".format(thread_name))