Start the interface

        :param blocking: Should the call block until stop() is called
            (default: False)
        :type blocking: bool
        :rtype: None
        :raises SensorStartException: Failed to start
424014
def start(self, blocking=False):
        
        self.debug("()")
        try:
            self._init_multicast_socket()
        except:
            self._multicast_socket = None
            self.exception("Failed to init multicast socket")
            raise SensorStartException("Multicast socket init failed")

        super(SensorServer, self).start(blocking=False)
        self._is_stopped.clear()
        try:
            a_thread = threading.Thread(
                target=self._thread_wrapper,
                args=(self._packet_loop,)
            )
            a_thread.daemon = True
            a_thread.start()
        except:
            self.exception("Failed to run packet loop")
            raise SensorStartException("Packet loop failed")
        self.info("Started")
        # Blocking
        super(Sensor, self).start(blocking)
584070
def on_connection_blocked(self, method_frame):
        
        LOGGER.warning('Connection blocked: %s', method_frame)
        self.state = self.STATE_BLOCKED
        if self.on_unavailable:
            self.on_unavailable(self)
1098963
public void start(int delay, final boolean blocking) {

        if (delay <= 0) {
            show(blocking);
            return;
        }
        m_timer = new Timer() {

            /**
             * @see com.google.gwt.user.client.Timer#run()
             */
            @Override
            public void run() {

                show(blocking);
            }
        };
        m_timer.schedule(delay);
    }
323224
def start(self):
        # type: () -> bool
        
        with self._lock:
            if self._state in (Bundle.STARTING, Bundle.ACTIVE):
                # Already started framework
                return False

            # Reset the stop event
            self._fw_stop_event.clear()

            # Starting...
            self._state = Bundle.STARTING
            self._dispatcher.fire_bundle_event(
                BundleEvent(BundleEvent.STARTING, self)
            )

            # Start all registered bundles (use a copy, just in case...)
            for bundle in self.__bundles.copy().values():
                try:
                    bundle.start()
                except FrameworkException as ex:
                    # Important error
                    _logger.exception(
                        "Important error starting bundle: %s", bundle
                    )
                    if ex.needs_stop:
                        # Stop the framework (has to be in active state)
                        self._state = Bundle.ACTIVE
                        self.stop()
                        return False
                except BundleException:
                    # A bundle failed to start : just log
                    _logger.exception("Error starting bundle: %s", bundle)

            # Bundle is now active
            self._state = Bundle.ACTIVE
            return True
248263
def start(self, blocking=False):
        
        super(StartStopable, self).start()
        self._is_running = True
        # blocking
        try:
            while blocking and self._is_running:
                time.sleep(self._start_block_timeout)
        except IOError as e:
            if not str(e).lower().startswith("[errno 4]"):
                raise
1260624
def start(self):
        
        if self._started:
            raise RuntimeError("thread already started")

        def run():
            try:
                self.run(*self._args, **self._kwargs)
            except SystemExit:
                # only shut down the thread, not the whole process
                pass
            finally:
                self._deactivate()

        self._glet = scheduler.greenlet(run)
        self._ident = id(self._glet)
        scheduler.schedule(self._glet)
        self._activate()
415865
private synchronized void start() {
        // only reschedule if monitor is still active (not in the process of being initialized or destroyed
        // don't schedule a task if there are no monitors or the monitorInterval was set to 0
        // don't schedule a task if the framework is stopping
        if (scheduledFuture == null
            && monitorState.get() == MonitorState.ACTIVE.ordinal()
            && !updateMonitors.isEmpty()
            && monitorInterval != 0
            && FrameworkState.isValid()) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                Tr.event(this, tc, "Scan task scheduled");
            }
            scheduledFuture = coreService.getScheduler().scheduleWithFixedDelay(this, monitorInterval, monitorInterval, monitorTimeUnit);
        }
    }
399607
def start(self, blocking=False):
        
        self.debug("()")
        # Start the plugins
        for plugin in self.plugins:
            try:
                # Inject self into plugin
                plugin.controller = self
                plugin.start(blocking=False)
            except:
                self.exception(
                    u"Failed to start plugin {}".format(plugin.name)
                )
                raise PluginStartException(
                    "Starting one or more plugins failed"
                )
        super(CrowdController, self).start(blocking=blocking)
814805
def on_start(self):
        
        LOGGER.debug("rabbitmq.Service.on_start")
        self.connection = pika.BlockingConnection(self.parameters)
        self.channel = self.connection.channel()
        self.channel.queue_declare(queue=self.serviceQ, auto_delete=True)
        self.channel.basic_consume(self.on_request, self.serviceQ)
        self.service = threading.Thread(target=self.run, name=self.service_name)
        self.service.start()
        self.is_started = True
636996
def start(self, *args, **kwargs):#pylint:disable=unused-argument
        
        restart = kwargs.get('restart', True)
        return self.run(restart)
447232
def start(self):
        
        if self.__framework._state not in (Bundle.STARTING, Bundle.ACTIVE):
            # Framework is not running
            raise BundleException(
                "Framework must be started before its bundles"
            )

        with self._lock:
            if self._state in (Bundle.ACTIVE, Bundle.STARTING):
                # Already started bundle, do nothing
                return

            # Store the bundle current state
            previous_state = self._state

            # Starting...
            self._state = Bundle.STARTING
            self._fire_bundle_event(BundleEvent.STARTING)

            # Call the activator, if any
            starter = self.__get_activator_method("start")
            if starter is not None:
                try:
                    # Call the start method
                    starter(self.__context)
                except (FrameworkException, BundleException):
                    # Restore previous state
                    self._state = previous_state

                    # Re-raise directly Pelix exceptions
                    _logger.exception(
                        "Pelix error raised by %s while starting", self.__name
                    )
                    raise
                except Exception as ex:
                    # Restore previous state
                    self._state = previous_state

                    # Raise the error
                    _logger.exception(
                        "Error raised by %s while starting", self.__name
                    )
                    raise BundleException(ex)

            # Bundle is now active
            self._state = Bundle.ACTIVE
            self._fire_bundle_event(BundleEvent.STARTED)
508269
private void start()
    {
    try
      {
      // Initialize filter.
      initializeFilter( getFilterInput(), getFilterOutput());

      // Start filter thread.
      failure_ = null;
      thread_ = new Thread( this, String.valueOf( this));
      thread_.start();
      }
    catch( Exception e)
      {
      throw new RuntimeException( "Can't start filtering", e);
      } 
    }
1080173
def block(self):
        

        self._nosig = True
        yield
        self._nosig = False
        if self._interrupted:
            raise SystemExit("Aborted...")
939996
def initialize(self, force=False):
        
        if force or (self.isVisible() and \
                     not self.isInitialized() and \
                     not self.signalsBlocked()):
            
            self._initialized = True
            self.initialized.emit()
709375
public void run() {
        if(log.isDebugEnabled()) {
            log.debug("ListenerThread Starting.");
        }

        while(running) {
            try {
                Socket clientSocket = serverSocket.accept();

                WorkerThread worker = new WorkerThread(container, clientSocket);
                worker.start();

            } catch(SocketTimeoutException ste) {
                // Ignore. We receive one of these every second, when the accept()
                // method times out. This is done to give us the opportunity to break
                // out of the blocking accept() call in order to shut down cleanly.

            } catch(Exception e) {
                if(log.isErrorEnabled()) {
                    log.error("Error Accepting: " + e.toString(), e);
                }
            }
        }

		try {
			serverSocket.close();
			
		} catch (IOException e) {
			if(log.isErrorEnabled()) {
				log.error("Error closing the server socket: " + e.toString(), e);
			}
		}
    }
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')
389682
private void beginMainBlock() {
        int blockNo = registerBlock(null); // =0
        BlockTabRec btr = blockTab[blockNo];
        btr.tPosBegin = 0;
        btr.tPosContentsBegin = 0;
        openBlocksTab[currentNestingLevel] = blockNo;
        currentNestingLevel++;
    }