Pauses the current process for the given delay (in simulated time). The process will be resumed when the simulation
    has advanced to the moment corresponding to `now() + delay`.
768825
def advance(delay: float) -> None:
    
    if _logger is not None:
        _log(INFO, "Process", local.name, "advance", delay=delay)
    curr = Process.current()
    rsim = curr.rsim
    id_wakeup = rsim()._schedule(delay, curr.switch)  # type: ignore

    try:
        rsim()._gr.switch()                   # type: ignore
    except Interrupt:
        rsim()._cancel(id_wakeup)             # type: ignore
        raise
987768
public void setPaused (boolean paused)
    {
        // sanity check
        if ((paused && (_pauseTime != 0)) || (!paused && (_pauseTime == 0))) {
            log.warning("Requested to pause when paused or vice-versa", "paused", paused);
            return;
        }

        _paused = paused;
        if (_paused) {
            // make a note of our pause time
            _pauseTime = _framemgr.getTimeStamp();

        } else {
            // let the animation and sprite managers know that we just warped into the future
            long delta = _framemgr.getTimeStamp() - _pauseTime;
            _animmgr.fastForward(delta);
            _spritemgr.fastForward(delta);

            // clear out our pause time
            _pauseTime = 0;
        }
    }
679047
function defer(cb) {
    if (storage.LATENCY === 0 && typeof process !== 'undefined') {
      process.nextTick(cb);
    } else {
      setTimeout(cb, storage.LATENCY);
    }
  }
748784
def resume(self):
        """"""
        with self.condition:
            self.paused = False
            self.condition.notify_all()
764109
public static void pause(long milli) {
		final Thread t = Thread.currentThread();
		long start = System.currentTimeMillis();
		while( System.currentTimeMillis() - start < milli ) {
			synchronized( t )  {
				try {
					long target = milli - (System.currentTimeMillis() - start);
					if( target > 0 )
						t.wait(target);
				} catch (InterruptedException ignore) {
				}
			}
		}
	}
499187
public synchronized final void pause() {
        if (isStop) return ;

        isPause = true;
        mPauseTimeInFuture = mStopTimeInFuture - SystemClock.elapsedRealtime();
        mHandler.removeMessages(MSG);
    }
697604
def _finish(self, ispausing):
        
        if ispausing:
            self.log.debug('%s paused' % repr(self))
        else:
            self._finished.set()
            self.log.debug('%s finished' % repr(self))
108475
def pause(self):
		

		# Change playback status only if current status is PLAYING or PAUSED 
		# (and not READY).
		logger.debug("Pausing playback")
		if self.status == PAUSED:
			# Recalculate audio stream position to make sure it is not out of
			# sync with the video
			self.__calculate_audio_frames()
			self.status = PLAYING
			self.clock.pause()
		elif self.status == PLAYING:
			self.status = PAUSED
			self.clock.pause()
30081
private static void pause( final long time )
    {
        final long startTime = System.currentTimeMillis();
        do
        {
            try
            {
                final long sleepTime = time - ( System.currentTimeMillis() - startTime );
                Thread.sleep( sleepTime > 0 ? sleepTime : 10 );
            }
            catch ( InterruptedException e )
            {
                //don't care
            }
        } while ( ( System.currentTimeMillis() - startTime ) < time );
    }
303720
private void scheduleBatchProcess(boolean immediate) {
        synchronized (mutex) {
            if (inbox.size() == 0)
                return;

            // Schedule the processing. To improve latency, if we haven't processed anything
            // in at least our delay time, rush these object(s) through a minimum delay:
            long suggestedDelay = 0;
            if (!immediate && inbox.size() < capacity) {
                // Check with the last processed time:
                if (System.currentTimeMillis() - lastProcessedTime < delay)
                    suggestedDelay = delay;
                else {
                    // Note: iOS schedules with 0 delay but the iOS implementation
                    // works on the runloop which still allows the current thread
                    // to continue queuing objects to the batcher until going out of
                    // the runloop. Java cannot do the same so giving a small delay to
                    // allow objects to be added to the batch if available:
                    suggestedDelay = Math.min(SMALL_DELAY_AFTER_LONG_PAUSE, delay);
                }
            }
            scheduleWithDelay(suggestedDelay);
        }
    }
710898
def delay(self, wait, *args):
        

        def call_it():
            self.obj(*args)

        t = Timer((float(wait) / float(1000)), call_it)
        t.start()
        return self._wrap(self.obj)
255109
public void pause()
    {
        if (mAudioListener != null)
        {
            int sourceId = getSourceId();
            if (sourceId != GvrAudioEngine.INVALID_ID)
            {
                mAudioListener.getAudioEngine().pauseSound(sourceId);
            }
        }
    }
45838
def pause(self, length=None, **kwargs):
        
        return self.nest(Pause(length=length, **kwargs))
83781
def pause(jid, state_id=None, duration=None):
    '''
    
    '''
    minion = salt.minion.MasterMinion(__opts__)
    minion.functions['state.pause'](jid, state_id, duration)
829710
private function _process_paused() {

        // copy all requests to another variable
        $urls = $this->_requests;

        // while there are URLs to process
        while (!empty($urls)) {

            // get from the entire list of requests as many as specified by the "threads" property
            $this->_requests = array_splice($urls, 0, $this->threads, array());

            // process those requests
            $this->_process();

            // wait for as many seconds as specified by the "pause_interval" property
            if (!empty($urls)) sleep($this->pause_interval);

        }

    }
46207
async def pause(self, pause: bool = True):
        
        self._paused = pause
        await self.node.pause(self.channel.guild.id, pause)
548731
def _delay(self, ms):
        
        if ms:
            self.Delay(ms)
        else:
            if self.default_delay:
                self.Delay(self.default_delay)