Start the listener.

        This starts up a background thread to monitor the queue for
        items to process.
346410
def start(self):
        
        self._thread = t = threading.Thread(target=self._monitor)
        t.setDaemon(True)
        t.start()
933679
public synchronized void start() throws SocketException {
        if (!isRunning()) {
            DeviceFinder.getInstance().addLifecycleListener(lifecycleListener);
            DeviceFinder.getInstance().addDeviceAnnouncementListener(announcementListener);
            DeviceFinder.getInstance().start();
            for (DeviceAnnouncement device: DeviceFinder.getInstance().getCurrentDevices()) {
                requestPlayerDBServerPort(device);
            }

            new Thread(null, new Runnable() {
                @Override
                public void run() {
                    while (isRunning()) {
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                            logger.warn("Interrupted sleeping to close idle dbserver clients");
                        }
                        closeIdleClients();
                    }
                    logger.info("Idle dbserver client closer shutting down.");
                }
            }, "Idle dbserver client closer").start();

            running.set(true);
            deliverLifecycleAnnouncement(logger, true);
        }
    }
1340270
public void start() {
        if (log.isDebugEnabled()) {
            log.debug("Executing ThreadEx [target=" + target.getClass().getName() + "]");
        }
        ThreadUtil.startThread(this.thread);
    }
687155
public void     start()
    {
        Preconditions.checkState(Thread.currentThread().equals(ourThread), "Not in the correct thread");

        client.addParentWatcher(watcher);
    }
813456
public void start()
  {
    if (! getLifecycle().toStarting()) {
      startListeners();
      return;
    }
    
    //sendAddLoaderEvent();

    //bind();
    
    try {
      make();
    } catch (Exception e) {
      log().log(Level.WARNING, e.toString(), e);
      e.printStackTrace();
    }

    startListeners();

    getLifecycle().toActive();
    
    if (isAdminEnable()) {
      Thread thread = Thread.currentThread();
      ClassLoader loader = thread.getContextClassLoader();
      
      try {
        thread.setContextClassLoader(this);
      
        //_admin = new EnvironmentAdmin(this);
        //_admin.register();
      } finally {
        thread.setContextClassLoader(loader);
      }
    }
  }
453895
def start(self):
        """'"""
        self._process = threading.Thread(target=self._background_runner)
        self._process.start()
138400
private void executeListeners() {
    if (!monitor.isOccupiedByCurrentThread()) {
      // iterate by index to avoid concurrent modification exceptions
      for (int i = 0; i < listeners.size(); i++) {
        listeners.get(i).execute();
      }
    }
  }
398808
def start(self, *args, **kwargs):
        
        args = (self.counter,) + args
        thread = threading.Thread(
                target=self._work_callback,
                args=args, kwargs=kwargs
                )
        thread.setDaemon(self.daemon)
        thread.start()
476040
def start(self):
        
        self.__stop = False
        self._queue.start()
        self._zk.start()
1013336
def run(self):
		
		if not hasattr(self, 'queue'):
			raise RuntimeError("Audio queue is not intialized.")
		self.keep_listening = True
		self.stream.start()
		
		while self.keep_listening:
			try:
				chunk = self.queue.get(timeout=queue_timeout)
				underflowed = self.stream.write(chunk)
				if underflowed:
					logger.debug("Buffer underrun")
			except Empty:
				pass

		self.stream.stop()
		self.stream.close()
436748
def start(self):
        
        self.running = True
        self.thread = threading.Thread(target=self._main_loop)
        self.thread.start()
1347081
public void start() {
        Thread thread = new Thread(new LogCatCommandExecutor());
        thread.setName(getClass().getSimpleName() + " logcat for " + device.getSerialNumber());
        thread.start();

        try {
            sleep(500); // ignore old output that logcat feeds us
        } catch (InterruptedException e) {
        }

        logListenerCommandShell.activate();
    }
1130389
def run(self):
        

        try:
            self.__options.callbacks.request_in_thread_before_start(self.__queue_item)
        except Exception as e:
            print(e)

        new_requests = []
        failed = False

        try:
            handler = Handler(self.__options, self.__queue_item)
            new_requests = handler.get_new_requests()

            try:
                self.__queue_item.response.raise_for_status()
            except Exception:
                if self.__queue_item.request.parent_raised_error:
                    failed = True
                else:
                    for new_request in new_requests:
                        new_request.parent_raised_error = True

        except Exception as e:
            failed = True

            error_message = "Setting status of '{}' to '{}' because of an HTTP error.".format(
                self.__queue_item.request.url,
                QueueItem.STATUS_ERRORED
            )

            DebugHelper.output(self.__options, error_message)
            DebugHelper.output(self.__options, e)

            try:
                self.__options.callbacks.request_on_error(self.__queue_item, str(e))
            except Exception as e:
                print(e)

        for new_request in new_requests:
            new_request.parent_url = self.__queue_item.request.url

        try:
            self.__options.callbacks.request_in_thread_after_finish(self.__queue_item)
        except Exception as e:
            print(e)

        with self.__callback_lock:
            self.__callback(self.__queue_item, new_requests, failed)
871110
public void startListening()
    {
        // Register progress listener
        this.observationManager.addListener(new WrappedThreadEventListener(this.progress));

        // Isolate log for the job status
        this.logListener = new LoggerListener(LoggerListener.class.getName() + '_' + hashCode(), this.logs);
        if (isIsolated()) {
            this.loggerManager.pushLogListener(this.logListener);
        } else {
            this.observationManager.addListener(new WrappedThreadEventListener(this.logListener));
        }
    }
87649
def start(self):
        
        while True:
            self.thread_debug("Interval starting")
            for thr in threading.enumerate():
                self.thread_debug("    " + str(thr))
            self.feed_monitors()
            start = time.time()
            # wait fore queue to empty
            self.workers_queue.join()
            end = time.time()
            diff = self.config['interval']['test'] - (end - start)
            if diff <= 0:
                # alarm
                self.stats.procwin = -diff
                self.thread_debug("Cannot keep up with tests! {} seconds late"
                                  .format(abs(diff)))
            else:
                self.thread_debug("waiting {} seconds...".format(diff))
                time.sleep(diff)
1273544
def start(self):
        
        self.running = True
        self.attempt_connection()
        receiver_thread = self.create_thread_fc(self.__receiver_loop)
        receiver_thread.name = "StompReceiver%s" % getattr(receiver_thread, "name", "Thread")
        self.notify('connecting')
284840
def start(self):
        
        assert not self._started
        self._listening_stream.on_recv(self._recv_callback)
        self._started = True