自学教程：C++ stopping函数代码示例

    void    Periodic::onMain(void)    {      double now = Time::Clock::get();      double delay = (1 / m_frequency);      double next_inv = now + delay;      m_run_time = now;      while (!stopping())      {        delay = (1.0 / m_frequency);        if (next_inv > now)          Time::Delay::wait(next_inv - now);        next_inv += delay;        now = Time::Clock::get();        m_run_time = now;        // Perform job.        consumeMessages();        if (!stopping())        {          task();          ++m_run_count;        }        now = Time::Clock::get();      }    }

static void *send_thread(void *data){	struct rtmp_stream *stream = data;	os_set_thread_name("rtmp-stream: send_thread");	while (os_sem_wait(stream->send_sem) == 0) {		struct encoder_packet packet;		if (stopping(stream) && stream->stop_ts == 0) {			break;		}		if (!get_next_packet(stream, &packet))			continue;		if (stopping(stream)) {			if (can_shutdown_stream(stream, &packet)) {				obs_free_encoder_packet(&packet);				break;			}		}		if (!stream->sent_headers) {			if (!send_headers(stream)) {				os_atomic_set_bool(&stream->disconnected, true);				break;			}		}		if (send_packet(stream, &packet, false, packet.track_idx) < 0) {			os_atomic_set_bool(&stream->disconnected, true);			break;		}	}	if (disconnected(stream)) {		info("Disconnected from %s", stream->path.array);	} else {		info("User stopped the stream");	}	RTMP_Close(&stream->rtmp);	if (!stopping(stream)) {		pthread_detach(stream->send_thread);		obs_output_signal_stop(stream->output, OBS_OUTPUT_DISCONNECTED);	} else {		obs_output_end_data_capture(stream->output);	}	free_packets(stream);	os_event_reset(stream->stop_event);	os_atomic_set_bool(&stream->active, false);	stream->sent_headers = false;	return NULL;}

int ThreadedAudioDevice::doStop(){	if (!stopping()) {		PRINT1("/tThreadedAudioDevice::doStop/n");		stopping(true);		// signals play thread		paused(false);		waitForThread();		starting(false);	}	return 0;}

 void AdmittanceController::setMode(unsigned int mode) {     if (mode_ != mode) {         stopping();         mode_ = mode;         starting();     } }

int ThreadedAudioDevice::waitForDevice(unsigned int wTime) {	int ret;	unsigned waitSecs = int(wTime / 1000.0);	unsigned waitUsecs = 1000 * (wTime - unsigned(waitSecs * 1000));	// Wait wTime msecs for select to return, then bail.	if (!stopping()) {		int nfds = _device + 1;		struct timeval tv;		tv.tv_sec = waitSecs;		tv.tv_usec = waitUsecs;		// If wTime == 0, wait forever by passing NULL as the final arg.//		if (!isPlaying())//			printf("select(%d, 0x%x, 0x%x, NULL, 0x%x).../n", //					nfds, &_rfdset, &_wfdset, wTime == 0 ?  NULL : &tv);		int selret = ::select(nfds, &_rfdset, &_wfdset,							  NULL, wTime == 0 ?  NULL : &tv);		if (selret <= 0) {			if (errno != EINTR)				fprintf(stderr,						"ThreadedAudioDevice::waitForDevice: select %s/n",						(selret == 0) ? "timed out" : "returned error");			ret = -1;		}		else {			setFDSet();			ret = 0;		}	}	else {		PRINT1("ThreadedAudioDevice::waitForDevice: stopping == true/n");		ret = 1;	}	return ret;}

void Insteon::run(){    setStarted();    while (!stopping())    {        // Make sure every devices are idle before atempting to send another command        bool devicesIdle = true;        for (std::map<InsteonID,InsteonDevice*>::iterator it = mModules.begin();it!=mModules.end();it++)        {            time_t t;            time(&t);            it->second->onTimer(t);            if (!it->second->isIdle())            {                devicesIdle = false;                break;            }        }        if (mpInsteonModem->process(devicesIdle))        {            // dont sleep more than 50ms because Insteon modem expects reponses within 85ms            usleep(50000);        }    }}

static void rtmp_stream_destroy(void *data){	struct rtmp_stream *stream = data;	if (stopping(stream) && !connecting(stream)) {		pthread_join(stream->send_thread, NULL);	} else if (connecting(stream) || active(stream)) {		if (stream->connecting)			pthread_join(stream->connect_thread, NULL);		os_event_signal(stream->stop_event);		if (active(stream)) {			os_sem_post(stream->send_sem);			obs_output_end_data_capture(stream->output);			pthread_join(stream->send_thread, NULL);		}	}	if (stream) {		free_packets(stream);		dstr_free(&stream->path);		dstr_free(&stream->key);		dstr_free(&stream->username);		dstr_free(&stream->password);		dstr_free(&stream->encoder_name);		os_event_destroy(stream->stop_event);		os_sem_destroy(stream->send_sem);		pthread_mutex_destroy(&stream->packets_mutex);		circlebuf_free(&stream->packets);		bfree(stream);	}}

static bool init_connect(struct rtmp_stream *stream){	obs_service_t *service;	obs_data_t *settings;	if (stopping(stream))		pthread_join(stream->send_thread, NULL);	free_packets(stream);	service = obs_output_get_service(stream->output);	if (!service)		return false;	os_atomic_set_bool(&stream->disconnected, false);	stream->total_bytes_sent = 0;	stream->dropped_frames   = 0;	stream->min_drop_dts_usec= 0;	stream->min_priority     = 0;	settings = obs_output_get_settings(stream->output);	dstr_copy(&stream->path,     obs_service_get_url(service));	dstr_copy(&stream->key,      obs_service_get_key(service));	dstr_copy(&stream->username, obs_service_get_username(service));	dstr_copy(&stream->password, obs_service_get_password(service));	stream->drop_threshold_usec =		(int64_t)obs_data_get_int(settings, OPT_DROP_THRESHOLD) * 1000;	stream->max_shutdown_time_sec =		(int)obs_data_get_int(settings, OPT_MAX_SHUTDOWN_TIME_SEC);	obs_data_release(settings);	return true;}

      //! Main loop.      void      onMain(void)      {        Counter<double> m_mon_timer(1.0);        while (!stopping())        {          waitForMessages(1.0);          if (m_wdog.overflow())          {            setEntityState(IMC::EntityState::ESTA_ERROR, Status::CODE_COM_ERROR);            throw RestartNeeded(Status::getString(Status::CODE_COM_ERROR), c_restart_delay);          }          else          {            setEntityState(IMC::EntityState::ESTA_NORMAL, Status::CODE_ACTIVE);          }          if (m_mon_timer.overflow())          {            m_mon_timer.reset();            getMonitors();          }        }      }

      void      onMain(void)      {        char bfr[32];        while (!stopping())        {          consumeMessages();          if (m_wdog.overflow())          {            setEntityState(IMC::EntityState::ESTA_ERROR, Status::CODE_COM_ERROR);            throw RestartNeeded(DTR(Status::getString(CODE_COM_ERROR)), 5);          }          if (!Poll::poll(*m_uart, 1.0))            continue;          size_t rv = m_uart->readString(bfr, sizeof(bfr));          if (rv == 0)            throw RestartNeeded(DTR("I/O error"), 5);          if (std::sscanf(bfr, "%f", &m_sspeed.value) != 1)            continue;          if ((m_sspeed.value < c_min_speed) || (m_sspeed.value > c_max_speed))            m_sspeed.value = -1;          m_wdog.reset();          dispatch(m_sspeed);        }      }

static void *connect_thread(void *data){	struct rtmp_stream *stream = data;	int ret;	os_set_thread_name("rtmp-stream: connect_thread");	if (!init_connect(stream)) {		obs_output_signal_stop(stream->output, OBS_OUTPUT_BAD_PATH);		return NULL;	}	ret = try_connect(stream);	if (ret != OBS_OUTPUT_SUCCESS) {		obs_output_signal_stop(stream->output, ret);		info("Connection to %s failed: %d", stream->path.array, ret);	}	if (!stopping(stream))		pthread_detach(stream->connect_thread);	os_atomic_set_bool(&stream->connecting, false);	return NULL;}

voidEndSequence::stop(){  if (!isrunning) return;  isrunning = false;  isdone = true;  stopping();}

 void BasicUAVAutopilot::onMain(void) {   while (!stopping())   {     waitForMessages(1.0);   } }

 void onMain(void) {   while (!stopping())   {     waitForMessages(1.0);   } }

voidEventLoop::idle(){    while (!stopping()) {        MORDOR_LOG_DEBUG(g_log) << m_messageWindow << " Starting new message pump";        schedule(boost::bind(&EventLoop::messagePump, this));        Fiber::yield();    }}

bool MeasureThreadCounter::runnable(){	int seconds(m_nSeconds), wait;	if(m_bClientAction)	{		tout << "server wait for some action from any client" << endl;		tout << "and count after that ";	}else		tout << "server count now ";	tout << "between " << getTimeString(seconds, &wait) << "for running folder threads." << endl;	TERMINALEND;	if(m_bClientAction)	{		LOCK(m_CLIENTACTIONMUTEX);		m_bCounting= false;		while(!m_bClientActionDone)		{			CONDITION(m_CLIENTACTIONCOND, m_CLIENTACTIONMUTEX);			if(stopping())			{				m_bCounting= true;				UNLOCK(m_CLIENTACTIONMUTEX);				return false;			}		}		beginCount();		AROUSEALL(m_CLIENTACTIONCOND);		m_bCounting= true;		tout << "wait now for " << getTimeString(seconds, &wait) << endl;		if(m_bClientAction)		{			tout << "  activated from " << m_tClient.who << endl;			tout << "    to inform " << m_tClient.folder << ":" << m_tClient.subroutine							<< " set with value " << m_tClient.value << endl;		}		UNLOCK(m_CLIENTACTIONMUTEX);		TERMINALEND;	}else		beginCount();	do{		//cout << "sleep for " << wait << " seconds" << endl;		if(SLEEP(wait) != ETIMEDOUT)		{			outputCounting(m_nSeconds - seconds);			return false;		}		seconds-= wait;		if(seconds > 0)		{			tout << "wait for " << getTimeString(seconds, &wait) << endl;			TERMINALEND;		}	}while(seconds > 0);	outputCounting(m_nSeconds);	return false;}

      void      onMain(void)      {        setInitialState();        while (!stopping())        {          if (m_report_timer.overflow())          {            if (m_args.progress)              reportProgress();            dispatch(m_pcs);            m_report_timer.reset();          }          double now = Clock::get();          if ((getEntityState() == IMC::EntityState::ESTA_NORMAL) &&              (now - m_last_vstate >= c_vs_timeout))          {            changeMode(IMC::PlanControlState::PCS_BLOCKED, DTR("vehicle state timeout"));            m_last_vstate = now;          }          // got requests to process          if (!pendingReply() && m_requests.size())          {            processRequest(&m_requests.front());            m_requests.pop();          }          double delta = m_vc_reply_deadline < 0 ? 1 : m_vc_reply_deadline - now;          if (delta > 0)          {            waitForMessages(std::min(1.0, delta));            continue;          }          // handle reply timeout          m_vc_reply_deadline = -1;          changeMode(IMC::PlanControlState::PCS_READY, DTR("vehicle reply timeout"));          // Popping all requests          while (m_requests.size())            m_requests.pop();          // Increment local request id to prevent old replies from being processed          ++m_vreq_ctr;          err(DTR("cleared all requests"));        }      }

void eStreamThread::stop() {	if(!stopping())	{		m_stop = true;		::ioctl(m_destfd, 0);		kill();	}	else		eDebug("eStreamThread::stop: thread already stopping, ignoring kill request!");}

void obs_output_force_stop(obs_output_t *output){	if (!obs_output_valid(output, "obs_output_force_stop"))		return;	if (!stopping(output)) {		output->stop_code = 0;		do_output_signal(output, "stopping");		obs_output_actual_stop(output, true, 0);	}}

 void onMain(void) {   while (!stopping())   {     waitForMessages(1.0);     // Check if we receive valid GPS data.     if (m_time_without_gps.overflow())       setEntityState(IMC::EntityState::ESTA_ERROR, Status::CODE_WAIT_GPS_FIX);   } }

	Window::~Window() {		stopping();				SDL_HideWindow(_window);				SDL_GL_DeleteContext(_context);				SDL_DestroyWindow(_window);				SDL_QuitSubSystem(SDL_INIT_VIDEO);	}

voidServerImpl::stop (bool wait){    if (! stopping())    {        m_work = boost::none;        update();    }    if (wait)        m_stopped.wait();}

static bool init_connect(struct rtmp_stream *stream){	obs_service_t *service;	obs_data_t *settings;	const char *bind_ip;	int64_t drop_p;	int64_t drop_b;	if (stopping(stream)) {		pthread_join(stream->send_thread, NULL);	}	free_packets(stream);	service = obs_output_get_service(stream->output);	if (!service)		return false;	os_atomic_set_bool(&stream->disconnected, false);	stream->total_bytes_sent = 0;	stream->dropped_frames   = 0;	stream->min_priority     = 0;	settings = obs_output_get_settings(stream->output);	dstr_copy(&stream->path,     obs_service_get_url(service));	dstr_copy(&stream->key,      obs_service_get_key(service));	dstr_copy(&stream->username, obs_service_get_username(service));	dstr_copy(&stream->password, obs_service_get_password(service));	dstr_depad(&stream->path);	dstr_depad(&stream->key);	drop_b = (int64_t)obs_data_get_int(settings, OPT_DROP_THRESHOLD);	drop_p = (int64_t)obs_data_get_int(settings, OPT_PFRAME_DROP_THRESHOLD);	stream->max_shutdown_time_sec =		(int)obs_data_get_int(settings, OPT_MAX_SHUTDOWN_TIME_SEC);	if (drop_p < (drop_b + 200))		drop_p = drop_b + 200;	stream->drop_threshold_usec = 1000 * drop_b;	stream->pframe_drop_threshold_usec = 1000 * drop_p;	bind_ip = obs_data_get_string(settings, OPT_BIND_IP);	dstr_copy(&stream->bind_ip, bind_ip);	stream->new_socket_loop = obs_data_get_bool(settings,			OPT_NEWSOCKETLOOP_ENABLED);	stream->low_latency_mode = obs_data_get_bool(settings,			OPT_LOWLATENCY_ENABLED);	obs_data_release(settings);	return true;}

    void    Maneuver::onMain(void)    {      dispatch(m_rm);      while (!stopping())      {        if (isActive())          onStateReport();        waitForMessages(1.0);      }    }

  void  Daemon::onMain(void)  {    while (!stopping())    {      waitForMessages(1.0);      if (m_periodic_counter.overflow())      {        m_periodic_counter.reset();        dispatchPeriodic();      }    }  }

void BaseADCDebugLogger::stop(){    std::lock_guard<std::mutex> lock(_mutex);    _triggerState = false;    _preSamplesCount = 0;    _postSamplesCount = 0;    if (_workState == SavingState)        return;    _workState = NotWorkingState;    stopping();}

int ThreadedAudioDevice::startThread(){	stopping(false);	// Reset.	if (isPassive())	// Nothing else to do here if passive mode.		return 0;	starting(true);#ifdef PROFILE	getitimer(ITIMER_PROF, &globalTimerVal);#endif	PRINT1("/tThreadedAudioDevice::startThread: starting thread/n");	int status = pthread_create(&_thread, NULL, _runProcess, this);	if (status < 0) {		error("Failed to create thread");	}	return status;}

      void      onMain(void)      {        while (!stopping())        {          if (!isInitialized() || !isActive())          {            waitForMessages(1.0);            continue;          }          if (!m_ping_time.overflow())          {            waitForMessages(m_args.ping_delay);            continue;          }          double tstamp = Time::Clock::getSinceEpoch();          for (m_beacon = m_beacons.begin(); m_beacon < m_beacons.end(); ++m_beacon)          {            // Compute error.            double error = 0;            if (m_args.bad_range_prob > 0 && m_prng->random() % 100 <= m_args.bad_range_prob)              error = c_huge_error;            else if (m_args.sigma > 0)              error = m_prng->gaussian() * m_args.sigma;            //! Compute range.            double xd = m_sstate.x - m_beacon->x;            double yd = m_sstate.y - m_beacon->y;            double zd = m_sstate.z - m_beacon->depth;            IMC::LblRange range;            range.setTimeStamp(tstamp);            range.id = m_beacon->id;            range.range = std::sqrt(xd * xd + yd * yd + zd * zd);            range.range += error;            dispatch(range, DF_KEEP_TIME);            trace("beacon %u, range of %0.2f m, simulated error of %0.2f m",                  range.id, range.range, error);          }          // Setup next ping.          m_ping_time.reset();        }      }

static void rtmp_stream_destroy(void *data){	struct rtmp_stream *stream = data;	if (stopping(stream) && !connecting(stream)) {		pthread_join(stream->send_thread, NULL);	} else if (connecting(stream) || active(stream)) {		if (stream->connecting)			pthread_join(stream->connect_thread, NULL);		stream->stop_ts = 0;		os_event_signal(stream->stop_event);		if (active(stream)) {			os_sem_post(stream->send_sem);			obs_output_end_data_capture(stream->output);			pthread_join(stream->send_thread, NULL);		}	}	free_packets(stream);	dstr_free(&stream->path);	dstr_free(&stream->key);	dstr_free(&stream->username);	dstr_free(&stream->password);	dstr_free(&stream->encoder_name);	dstr_free(&stream->bind_ip);	os_event_destroy(stream->stop_event);	os_sem_destroy(stream->send_sem);	pthread_mutex_destroy(&stream->packets_mutex);	circlebuf_free(&stream->packets);#ifdef TEST_FRAMEDROPS	circlebuf_free(&stream->droptest_info);#endif	os_event_destroy(stream->buffer_space_available_event);	os_event_destroy(stream->buffer_has_data_event);	os_event_destroy(stream->socket_available_event);	os_event_destroy(stream->send_thread_signaled_exit);	pthread_mutex_destroy(&stream->write_buf_mutex);	if (stream->write_buf)		bfree(stream->write_buf);	bfree(stream);}

static void rtmp_stream_stop(void *data){	struct rtmp_stream *stream = data;	if (stopping(stream))		return;	if (connecting(stream))		pthread_join(stream->connect_thread, NULL);	os_event_signal(stream->stop_event);	if (active(stream)) {		os_sem_post(stream->send_sem);		obs_output_end_data_capture(stream->output);	}}