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

	void syserr(const char * msg)	{		if(current_game == error_game)			return;		std::cerr << msg << std::endl;		suspend();		message(msg, love::TAG_ERROR);	}

void osd_state::switch_to_internal_video_mode(){    if ( m_current_state != suspended){      suspend();    }    m_current_state = internal_video;    detail::video_setup();}

// release releases the interface to the font object //void APIText::release() {  suspend();  if (d3dfont) {    d3dfont->Release();    d3dfont = nullptr;  }}

int main ( int argc, char **argv ){	int mode = 0;	int ac_resusp = 0;	int fix_rtc = 0;	int opt;	while (( opt = getopt ( argc, argv, "a:frs" )) != EOF ) {		switch ( opt ) {			case 's':				mode = 's';				break;			case 'r':				mode = 'r';				break;			case 'a':				ac_resusp = atoi ( optarg );				if ( ac_resusp < 30 ) {					ac_resusp = 120;					fprintf ( stderr, "Warning: resuspend timeout must be >= 30 sec. -- now set to 120 sec/n" );				}				break;			case 'f':				fix_rtc = 1;				break;			default:				usage ( );		}	}	if ( geteuid ( ) != 0 ) {		fprintf ( stderr, "You need root priviledges to run opiealarm." );		return 2;	}	if ( !mode )		usage ( );	parent_pid = getpid ( );	// kill running opiealarm	opiealarm_was_running = kill_with_pidfile ( );	remove_pidfile ( );	switch ( mode ) {		case 'r': opt = resume ( ac_resusp );		          break;		case 's':		default : opt = suspend ( fix_rtc );		          break;	}	parent_pid = 0;	return opt;}

bool mutex::lock(const bool wait) {    const THREAD_ID lock_id = get_thread_id();        while(atomic_if_then_assign(&_mutex_owner, lock_id, 0) != 0) {        if (wait) suspend(0);        else return false;    }    return true;}

void TVDemo::shell(){    suspend();    system("cls");    cout << "Type EXIT to return...";    system( getenv( "COMSPEC"));    resume();    redraw();}

	void syswarn(const char * msg)	{		if(current_game == error_game)			return;		std::cerr << msg << std::endl;		suspend();		message(msg, love::TAG_WARNING);	}

void C64::setNTSC(){    debug(2, "C64::setNTSC/n");	suspend();    vic.setChipModel(MOS6567_NTSC);	sid.setNTSC();	resume();}

/* * ************************************************************* * Clean up and terminate with exitcode given as argument * **************************************************************/void cleanup_and_exit( srv_opts_t *options ){   // cleanup e.g. free allocated pointers   if( options != NULL )   {   }   // and suspend process   suspend( options );}

voidKcsPower::releaseButton(unsigned nr){    if (nr == 1) {            suspend();        c64->cpu.releaseNmiLine(CPU::INTSRC_EXPANSION);        resume();    }};

void Search::exit() {	exitsearch = true;	suspend();	resume();	if (worker.joinable()) {		worker.join();	}	timer.stop();	stageTimer.stop();}

void ScriptTcl::runController(int task) {  scriptBarrier.publish(barrierStep++,task);  suspend();#ifdef NAMD_TCL  if ( task == SCRIPT_RUN || task == SCRIPT_CONTINUE || task == SCRIPT_MINIMIZE  ) {    doCallback(state->callback_labelstring.c_str(),               state->callback_valuestring.c_str());  }#endif}

voidC64::setPAL(){	suspend();	    vic->setChipModel(MOS6569_PAL);	sid->setPAL();    debug(2, "Switching VIC chip model to MOS6569 (PAL)/n");	resume();}

int__pthread_rwlock_timedwrlock (pthread_rwlock_t *rwlock,			      const struct timespec *abstime){  pthread_descr self;  pthread_extricate_if extr;  if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)    return EINVAL;  self = thread_self ();  /* Set up extrication interface */  extr.pu_object = rwlock;  extr.pu_extricate_func =  rwlock_wr_extricate_func;  /* Register extrication interface */  __pthread_set_own_extricate_if (self, &extr);  while(1)    {      __pthread_lock (&rwlock->__rw_lock, self);      if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)	{	  rwlock->__rw_writer = self;	  __pthread_set_own_extricate_if (self, 0);	  __pthread_unlock (&rwlock->__rw_lock);	  return 0;	}      /* Suspend ourselves, then try again */      enqueue (&rwlock->__rw_write_waiting, self);      __pthread_unlock (&rwlock->__rw_lock);      /* This is not a cancellation point */      if (timedsuspend (self, abstime) == 0)	{	  int was_on_queue;	  __pthread_lock (&rwlock->__rw_lock, self);	  was_on_queue = remove_from_queue (&rwlock->__rw_write_waiting, self);	  __pthread_unlock (&rwlock->__rw_lock);	  if (was_on_queue)	    {	      __pthread_set_own_extricate_if (self, 0);	      return ETIMEDOUT;	    }	  /* Eat the outstanding restart() from the signaller */	  suspend (self);	}    }}

void device_execute_interface::interface_pre_reset(){	// reset the total number of cycles	m_totalcycles = 0;	// enable all devices (except for disabled devices)	if (!disabled())		resume(SUSPEND_ANY_REASON);	else		suspend(SUSPEND_REASON_DISABLE, true);}

voidgenunimp (){    console_reset();#ifdef PCHIST    ppc();#endif /* PCHIST */    suspend();    console_init();    return;}

void yarn_suspend_on_time ( unsigned long usecs ){	yarn_t currentYarn;	unsigned long i;	TTDGET();	currentYarn = TTD.yarn_current->pid;	wait_graph_lock(wg);	wait_graph_insert(wg, currentYarn);	wait_graph_insert_time(wg, currentYarn, yarns_time() + usecs);	wait_graph_unlock(wg);	suspend();}

		void suspend_for(const boost::posix_time::time_duration& timeout, Callback&& cancel)		{			timer_.expires_from_now(timeout);			timer_.async_wait(				[&](const boost::system::error_code&)			{				resume();			});			suspend();			timer_.cancel();			cancel();			suspend();			if (interrupted_)				BOOST_THROW_EXCEPTION(interrupted_exception());		}

static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {    struct userdata *u = PA_SINK(o)->userdata;    switch (code) {        case PA_SINK_MESSAGE_GET_LATENCY:            *((pa_usec_t*) data) = sink_get_latency(u, &PA_SINK(o)->sample_spec);            return 0;        case PA_SINK_MESSAGE_SET_STATE:            switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {                case PA_SINK_SUSPENDED:                    pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));                    pa_smoother_pause(u->smoother, pa_rtclock_now());                    if (!u->source || u->source_suspended) {                        if (suspend(u) < 0)                            return -1;                    }                    u->sink_suspended = true;                    break;                case PA_SINK_IDLE:                case PA_SINK_RUNNING:                    if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {                        pa_smoother_resume(u->smoother, pa_rtclock_now(), true);                        if (!u->source || u->source_suspended) {                            if (unsuspend(u) < 0)                                return -1;                            u->sink->get_volume(u->sink);                            u->sink->get_mute(u->sink);                        }                        u->sink_suspended = false;                    }                    break;                case PA_SINK_INVALID_STATE:                case PA_SINK_UNLINKED:                case PA_SINK_INIT:                    ;            }            break;    }    return pa_sink_process_msg(o, code, data, offset, chunk);}

static void task_purger(rtems_task_argument arg){  while (true) {    suspend(RTEMS_SELF);    set_task_prio(RTEMS_SELF, PRIORITY_HIGH);    purge('P');  }  rtems_task_delete(RTEMS_SELF);}

void f(){  int i=0,flag=0;  while(1){    printf("tid :%d in f: %d/n",getID(),i++);    if(i>0 && !flag) {	suspend(tid);	flag = 1;		    }    usleep(90000);  }}

static int kbd_read( void* pNode, void* pCookie, off_t nPos, void* pBuf, size_t nLen ){    KbdVolume_s* 	psVolume = &g_sVolume;    int		nError;    if ( 0 == nLen ) {	return( 0 );    }	    for ( ;; )    {    	if ( atomic_read( &psVolume->nBytesReceived ) > 0 )	{	    int	nSize = min( nLen, atomic_read( &psVolume->nBytesReceived ) );	    int	i;	    char*	pzBuf = pBuf;	    for ( i = 0 ; i < nSize ; ++i ) {		pzBuf[ i ] = psVolume->zBuffer[ atomic_inc_and_read( &psVolume->nOutPos ) & 0xff ];	    }	    atomic_sub( &g_sVolume.nBytesReceived, nSize );				    nError = nSize;	}	else	{	    int	nEFlg = cli();	    if ( -1 != psVolume->hWaitThread )	    {		nError = -EBUSY;		printk( "ERROR : two threads attempted to read from keyboard device!/n" );	    }	    else	    {		if ( 1 )		{		    nError = -EWOULDBLOCK;		}		else		{		    psVolume->hWaitThread = get_thread_id(NULL);		    nError = suspend();		    psVolume->hWaitThread = -1;		}	    }	    put_cpu_flags( nEFlg );	}	if ( 0 != nError ) {	    break;	}    }    return( nError );}

void Game::update(float interval){	updateEnvironment(interval);	switch (mGameState) {		case STATE_MENU:			break;		case STATE_WAITING:			updateBall(sgoBall, interval);			if ((sgoBall.pos() - sgLookat).len() < 1.0f)			{				mCounter = 0.0f;				mGameState = STATE_COUNTDOWN;			}			break;		case STATE_COUNTDOWN:			mCounter += interval;			if (mCounter > COUNTDOWN_TIME)			{				enableBall();				mGameState = STATE_RUNNING;			}		case STATE_RUNNING:		if (wasKeyPressed(KEY_ESC))		{			Main::pushState(gScreenMain2);		}		/* manually switch features */		if (wasFunctionPressed(1))		{			setBallShadow(!useBallShadow());		}		if (wasFunctionPressed(2))		{			setReflection(!useReflection());		}		if (wasFunctionPressed(5))		{			suspend();			toggleMouseControl();			resume();		}		updateBall(sgoBall, interval);			break;	}	updateGameField(sgoBall);}

static void test_scheduler_move_heir(void){  bool per_cpu_state_ok;  _Thread_Disable_dispatch();  suspend(2);  suspend(3);  suspend(0);  resume(2);  suspend(1);  resume(3);  resume(0);  per_cpu_state_ok = is_per_cpu_state_ok();  resume(1);  _Thread_Enable_dispatch();  rtems_test_assert(per_cpu_state_ok);}

bool Thread::shutdown(){	// The thread will cleanly exit when it is done	running=false;	suspend();	// Now wait for the thread to shutdown	WaitForSingleObject(thread,INFINITE);	// It's destroyed, let's set our handle back to null	thread=NULL;	return true;}

Vst2413r::Vst2413r(audioMasterCallback audioMaster):   AudioEffectX(audioMaster, 0, 0),    driver_(44100){    if(audioMaster != NULL) {        setNumInputs(0);        setNumOutputs(1);        setUniqueID(kUniqueId);        canProcessReplacing();        isSynth();    }    suspend();}