Sleep amount of time in between iterations.
436009
private void doAutoSleep() {
        if (autoSleep > 0) {
            log.info("Sleeping " + autoSleep + " milliseconds");

            try {
                Thread.sleep(autoSleep);
            } catch (InterruptedException e) {
                log.error("Error during doc generation", e);
            }

            log.info("Returning after " + autoSleep + " milliseconds");
        }
    }
1013681
def random_sleep(self, previous_attempt_number, delay_since_first_attempt_ms):
        """"""
        return random.randint(self._wait_random_min, self._wait_random_max)
121042
def log_random_sleep(self, minimum=3.0, scale=1.0, hints=None):
        
        hints = '{} slept'.format(hints) if hints else 'slept'
        st = time.time()
        helper.random_sleep(minimum, scale)
        log.debug('{} {} {}s'.format(
            self.symbols.get('sleep', ''), hints, self.color_log(time.time() - st)))
1039624
public static void sleep(long millis) {
		try {
			Thread.sleep(millis);
		}
		catch (InterruptedException ex) {
			Thread.currentThread().interrupt();
		}
	}
1040104
private static void sleepFor(int time, TimeUnit units) {
        try {
            LOG.trace("Sleeping for {} {}", time, units.toString());
            Thread.sleep(units.toMillis(time));
        } catch (InterruptedException e) {
            // no-op
        }
    }
514320
def incrementing_sleep(self, previous_attempt_number, delay_since_first_attempt_ms):
        
        result = self._wait_incrementing_start + (self._wait_incrementing_increment * (previous_attempt_number - 1))
        if result > self._wait_incrementing_max:
            result = self._wait_incrementing_max
        if result < 0:
            result = 0
        return result
1035354
def sleep_walk(secs):
    '''
    
    '''
    start_time = datetime.now()
    num = 0
    while (datetime.now() - start_time).seconds < secs:
        num = num + 1
943185
public function sleep()
    {
        $now = microtime(true);
        $min = null;
        foreach ($this->untils as $id => $until) {
            $diff = $until - $now;
            if ($diff < 0) {
                // @codeCoverageIgnoreStart
                return;
                // @codeCoverageIgnoreEnd
            }
            if ($min !== null && $diff >= $min) {
                continue;
            }
            $min = $diff;
        }
        $min && usleep($min * 1000000);
    }
657564
private void applyWait(int fullTimes) {
        int newFullTimes = fullTimes > maxFullTimes ? maxFullTimes : fullTimes;
        if (fullTimes <= 3) { // 3次以内
            Thread.yield();
        } else { // 超过3次，最多只sleep 10ms
            LockSupport.parkNanos(1000 * 1000L * newFullTimes);
        }

    }
1153731
def _check_sleep(self, idx):
        """"""

        # TODO: There are some cases where it would be ok to do this...
        if not self.fake_time.slept[idx]:
            errstr = (
                "%s() function is not calling wpilib.Timer.delay() in its loop!"
                % self.mode_map[self.mode]
            )
            raise RuntimeError(errstr)

        self.fake_time.slept[idx] = False
1159295
public static boolean sleep(Number millis) {
		if (millis == null) {
			return true;
		}

		try {
			Thread.sleep(millis.longValue());
		} catch (InterruptedException e) {
			return false;
		}
		return true;
	}
196068
private final void sleepTill(long future) throws InterruptedException {
        long milliseconds = future - logicalClockMillis();
        if (milliseconds > 0) {
            Thread.sleep(milliseconds);
        }
    }
334386
def responsive_sleep(self, seconds, wait_reason=''):
        """"""
        for x in range(int(seconds)):
            if (self.config.wait_log_interval and
                not x % self.config.wait_log_interval):
                print('%s: %dsec of %dsec' % (wait_reason,
                                              x,
                                              seconds))
            time.sleep(1.0)
565893
def incrementing_sleep(self, previous_attempt_number, delay_since_first_attempt_ms):
        
        result = self._wait_incrementing_start + (self._wait_incrementing_increment * (previous_attempt_number - 1))
        if result < 0:
            result = 0
        return result
1256348
def no_sleep():
	
	mode = power.ES.continuous | power.ES.system_required
	handle_nonzero_success(power.SetThreadExecutionState(mode))
	try:
		yield
	finally:
		handle_nonzero_success(power.SetThreadExecutionState(power.ES.continuous))
501605
def sleep():
    
    if loop_duration == 0:
        raise BeatError("call beat.set_rate() before calling sleep")
    if loop_start_time == None:
        raise BeatError("call beat.true() before calling sleep")
    td = datetime.datetime.now() - loop_start_time
    duration_to_sleep = loop_duration - td.total_seconds()
    if duration_to_sleep < 0:
        raise BeatError("skipping sleep. Too much work!")
    time.sleep(duration_to_sleep)
801476
def sleep(seconds=0):
    
    loop = evergreen.current.loop
    current = Fiber.current()
    assert loop.task is not current
    timer = loop.call_later(seconds, current.switch)
    try:
        loop.switch()
    finally:
        timer.cancel()