Stop finding waveforms for all active players.
420738
@SuppressWarnings("WeakerAccess")
    public synchronized void stop() {
        if (isRunning()) {
            MetadataFinder.getInstance().removeTrackMetadataListener(metadataListener);
            running.set(false);
            pendingUpdates.clear();
            queueHandler.interrupt();
            queueHandler = null;

            // Report the loss of our waveforms, on the proper thread, outside our lock
            final Set<DeckReference> dyingPreviewCache = new HashSet<DeckReference>(previewHotCache.keySet());
            previewHotCache.clear();
            final Set<DeckReference> dyingDetailCache = new HashSet<DeckReference>(detailHotCache.keySet());
            detailHotCache.clear();
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    for (DeckReference deck : dyingPreviewCache) {  // Report the loss of our previews.
                        if (deck.hotCue == 0) {
                            deliverWaveformPreviewUpdate(deck.player, null);
                        }
                    }
                    for (DeckReference deck : dyingDetailCache) {  // Report the loss of our details.
                        if (deck.hotCue == 0) {
                            deliverWaveformDetailUpdate(deck.player, null);
                        }
                    }
                }
            });
            deliverLifecycleAnnouncement(logger, false);
        }
    }
676068
def stop(self):
        """"""
        if ZMQ:
            logging.warning(self.master.stop())
            z.context.term()
        self.db.close()
799178
def stop(self):
        """"""
        if self._progressing:
            self._progressing = False
            self._thread.join()
1210949
public synchronized void stop() {

        _coreMonitor.unregister();

        for (ServiceReg<FileMonitor> reg : _monitors.values()) {
            reg.unregister();
        }

        _monitors.clear();

        // Tidy up old location if we built it
        tidyUpMonitoredDirectory(createdMonitoredDir.get(), monitoredDirectory.get());
    }
1340253
def stopObserver(self):
        
        self._observer.isStopped = True
        self._observer.isRunning = False
214339
def stop_all(self):
        """"""
        if self.aotask is not None:
            self.aotask.stop()
        self.aitask.stop()
        self.daq_lock.release()
        self.aitask = None
        self.aotask = None
12847
def stop(self):
        """"""
        if not self.stopped:
            self.stopped = True
            if self.pendingHeartbeat is not None:
                self.pendingHeartbeat.cancel()
                self.pendingHeartbeat = None
1279388
def stop(self):
        """"""
        self._stopped = True
        threads = [self._accept_thread]
        threads.extend(self._server_threads)
        self._listening_sock.close()
        for sock in list(self._server_socks):
            try:
                sock.shutdown(socket.SHUT_RDWR)
            except socket.error:
                pass

            try:
                sock.close()
            except socket.error:
                pass

        with self._unlock():
            for thread in threads:
                thread.join(10)

        if self._uds_path:
            try:
                os.unlink(self._uds_path)
            except OSError:
                pass
1329995
@SuppressWarnings("WeakerAccess")
    public synchronized void stop() {
        if (isRunning()) {
            BeatFinder.getInstance().removeBeatListener(beatListener);
            VirtualCdj.getInstance().removeUpdateListener(updateListener);
            running.set(false);
            positions.clear();
            updates.clear();
            deliverLifecycleAnnouncement(logger, false);
        }
    }
715363
private final void stopHeartbeat() {

        if (timerTask != null && !HsqlTimer.isCancelled(timerTask)) {
            HsqlTimer.cancel(timerTask);

            timerTask = null;
        }
    }
1184924
def stop(self):
        
        if event.contains(self.field, 'set', self.__validate):
            event.remove(self.field, 'set', self.__validate)
1313570
def stop(self):
        
        self.debug("()")
        # Not sure if this is necessary, but good form
        if self._is_running:
            for gpio in self.gpios:
                GPIO.remove_event_detect(gpio)
            # Cleanup - includes used numbering scheme
        GPIO.cleanup()
        # Leave audience
        try:
            self.changer.on_person_leave(self.people)
        except:
            self.exception("Failed to remove people from audience")
        super(GPIODetector, self).stop()
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")
73338
def stop_sync(self):
        """"""

        # Disconnect connected device
        if self.connected:
            self.disconnect_sync(self._connection_handle)

        # Disable advertising
        self.set_advertising(False)
        # Stop the baBLE interface
        self.bable.stop()

        self.actions.queue.clear()
428693
def stop(self) -> None:
        
        if not self._running:
            return

        self._running = False
        self._receiving_queue.put_nowait((TRANSPARENT_EVENT, None))
        self._internal_queue.put_nowait((TRANSPARENT_EVENT, None))
117300
def stop(self) -> None:
        """"""
        self._running = False
        if self._timeout is not None:
            self.io_loop.remove_timeout(self._timeout)
            self._timeout = None
1089258
def stop(self):
        """"""

        for tile in self._tiles.values():
            tile.signal_stop()

        for tile in self._tiles.values():
            tile.wait_stopped()

        super(TileBasedVirtualDevice, self).stop()