Start a thread to handle SocketIO notifications.
762306
def start(self):
        """"""
        if not self._thread:
            _LOGGER.info("Starting SocketIO thread...")

            self._thread = threading.Thread(target=self._run_socketio_thread,
                                            name='SocketIOThread')
            self._thread.deamon = True
            self._thread.start()
70666
def __start(self):
        
        thread = Thread(target=self.__loop, args=())
        thread.daemon = True  # daemonize thread
        thread.start()
        self.__enabled = True
487163
def start_listening(self):
        """"""
        self._qlisten()
        self._halt_threads = False
        for t in self.queue_threads:
            t.start()
163549
def _start_handler_thread(self):
        """"""
        # Create handler thread
        t = Thread(target=self._start_loop)
        t.daemon = True

        # Start handler thread
        t.start()
        self.thread_started = True
253053
def handle_notification(self, msgtype, method, args, kwargs):
        """"""
        self.dispatch.call(method, args, kwargs)
1172698
def startThread(self):
        """"""
        if self._thread is not None:
            return
        self._thread = NSThread.alloc().initWithTarget_selector_object_(self, 'runPowerNotificationsThread', None)
        self._thread.start()
272015
def start(self):
        """"""
        self._init_topics()
        poll_thread = threading.Thread(target=self._poll_queue)
        poll_thread.start()
1027723
public void start() {
        try {
            while (keepGoing) {
                try {
                    // this is a blocking call so it hogs a thread
                    final Socket socket = ss.accept();
                    final String socketName = socket.getInetAddress().getHostAddress() + ":"
                            + socket.getPort();
                    log.info("accepted socket connection from " + socketName);
                    try {
                        final OutputStream out = socket.getOutputStream();

                        Subscriber<String> subscriber = createSubscriber(socket, socketName, out);
                        subscriptions.add(subscriber);
                        source.subscribeOn(Schedulers.io())
                                // remove subscriber from subscriptions on unsub
                                .doOnUnsubscribe(() -> subscriptions.remove(subscriber))
                                // write each line to the socket OutputStream
                                .subscribe(subscriber);

                    } catch (IOException e) {
                        // could not get output stream (could have closed very
                        // quickly after connecting)
                        // dont' care
                        log.warn(e.getClass().getSimpleName() + ": " + e.getMessage());
                    }
                } catch (SocketTimeoutException e) {
                    // don't care
                    log.warn(e.getClass().getSimpleName() + ": " + e.getMessage());
                }
            }
        } catch (IOException e) {
            if (keepGoing) {
                log.warn(e.getMessage(), e);
                throw new RuntimeException(e);
            } else
                log.info("server stopped");
        } finally {
            closeServerSocket();
        }
    }
1143156
public void start() throws IOException {
    server = ServerSocketChannel.open();
    server.configureBlocking(false);
    server.socket().setReuseAddress(true);
    server.socket().bind(new InetSocketAddress(port));

    monitor.add(server, this, SelectionKey.OP_ACCEPT);

    // Print a message when we are waiting to connect manually
    if (manualConnect) {
      System.out.println("Ready to accept connections on port " + port);
    }
  }
709905
def socket_worker(sock, msg_q):
    """"""
    _LOGGER.debug("Starting Socket Thread.")
    while True:
        try:
            data, addr = sock.recvfrom(1024)    # buffer size is 1024 bytes
        except OSError as err:
            _LOGGER.error(err)
        else:
            _LOGGER.debug("received message: %s from %s", data, addr)
            msg_q.put(data)
        time.sleep(0.2)
1139644
def start(self):
        
        with self._lock_send_remaining_time:
            if self._send_remaining_time <= 0.0:
                local_send_interval = self._send_interval
                if self._send_interval < 0.1:
                    local_send_interval = 0.1
                self._send_remaining_time = self._send_time
                if self._send_remaining_time < local_send_interval:
                    self._send_remaining_time = local_send_interval
                thread = Thread(target=self._run)
                thread.daemon = True
                thread.start()
775119
def start(self):
        """"""
        if not self.writeThread.isAlive() and not self.readThread.isAlive():
            self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.client.connect(self.ADDR)
            self.running = True
            self.writeThread.start()
            self.readThread.start()
349238
def start(self):
        """"""
        super(ResourceValues, self).start()
        self._api.ensure_notifications_thread()
        self._presubs.add(self._sdk_presub_params)
        if self._immediacy == FirstValue.on_value_update:
            self._subscribe_all_matching()
419764
public void start() throws Exception
    {
        if (isStarted())
            throw new IllegalStateException("Started");

        // Create a new server socket and set to non blocking mode
        _acceptChannel= ServerSocketChannel.open();
        _acceptChannel.configureBlocking(false);

        // Bind the server socket to the local host and port
        _acceptChannel.socket().bind(_address);

        // Read the address back from the server socket to fix issues
        // with listeners on anonymous ports
        _address= (InetSocketAddress)_acceptChannel.socket().getLocalSocketAddress();

        // create a selector;
        _selector= Selector.open();

        // Register accepts on the server socket with the selector.
        _acceptChannel.register(_selector, SelectionKey.OP_ACCEPT);

        // Start selector thread
        _selectorThread= new SelectorThread();
        _selectorThread.start();

        // Start the thread Pool
        super.start();
        log.info("Started SocketChannelListener on " + getHost()+":"+getPort());
    }
328478
def Start(self):
    """"""
    if not self.started:
      self.started = True
      for _ in range(self.min_threads):
        self._AddWorker()
1111451
def start(self, blocking=False):
        
        try:
            self._init_listen_socket()
        except:
            self.exception(u"Failed to init listen socket ({}:{})".format(
                self._listen_ip, self._listen_port
            ))
            self._shutdown_listen_socket()
            raise SensorStartException("Listen socket init failed")
        self.info(u"Listening on {}:{}".format(
            self._listen_ip, self._listen_port
        ))

        super(Sensor, self).start(False)
        try:
            a_thread = threading.Thread(
                target=self._thread_wrapper,
                args=(self._receiving,)
            )
            a_thread.daemon = True
            a_thread.start()
        except:
            self.exception("Failed to run receive loop")
            raise SensorStartException("Packet loop failed")
        super(Sensor, self).start(blocking)
985215
def run_thread(self):
        """"""
        self._run_thread = True
        self._thread.setDaemon(True)
        self._thread.start()