Sleeps for a few milliseconds.
979101
protected void sleep() {
    try {
      Thread.sleep(sleepIntervalInMillis);
    } catch (InterruptedException exception) {
      Thread.currentThread().interrupt();
      throw new SelendroidException(exception);
    }
  }
75968
def snooze(id, seconds = nil)
      wf_alert_id?(id)
      qs = seconds ? "?seconds=#{seconds}" : ''
      api.post([id, "snooze#{qs}"].uri_concat, nil)
    end
1289928
public void sleep(long backOffPeriod) throws InterruptedException {
		Object mutex = new Object();
		synchronized (mutex) {
			mutex.wait(backOffPeriod);
		}
	}
1101155
def responsive_sleep(self, seconds, wait_reason=''):
        """"""
        for x in xrange(int(seconds)):
            if (self.config.wait_log_interval and
                    not x % self.config.wait_log_interval):
                self.config.logger.debug(
                    '%s: %dsec of %dsec' % (wait_reason, x, seconds)
                )
            self.quit_check()
            time.sleep(1.0)
979548
private void sleeper(int count) {
        try {
            Thread.sleep(retryDelay * (long) count);
        } catch (InterruptedException ex) {
            LOG.trace("Sleep interrupted", ex);
        }
    }
382126
def every(secs):
    '''
    
    '''
    time_stated = time.monotonic()
    while True:
        time_yielded = time.monotonic()
        yield time_yielded - time_stated
        time.sleep(max(0, secs + time_yielded - time.monotonic()))
1068868
def delay(self):
        """"""
        if self.next_request_timestamp is None:
            return
        sleep_seconds = self.next_request_timestamp - time.time()
        if sleep_seconds <= 0:
            return
        message = "Sleeping: {:0.2f} seconds prior to" " call".format(
            sleep_seconds
        )
        log.debug(message)
        time.sleep(sleep_seconds)
1039624
public static void sleep(long millis) {
		try {
			Thread.sleep(millis);
		}
		catch (InterruptedException ex) {
			Thread.currentThread().interrupt();
		}
	}
796216
public void sleep(Deadline deadline)
	{
		final long millis = Math.min(deadline.getTimeLeft(), getMilliseconds());

		if (millis > 0)
		{
			try
			{
				Thread.sleep(millis);
			}
			catch (InterruptedException e)
			{
				// ignore but return
			}
		}
	}
224890
static void sleep(long n) {
    try {
      Thread.sleep(n);
    } catch (InterruptedException e) {
      LOG.warn("Thread interrupted", e);
      Thread.currentThread().interrupt();
    }
  }
841893
public SleepBuilder<T> withInterval(long interval, TimeUnit timeUnit) {
        this.interval = timeUnit.toMillis(interval);
        return this;
    }
462341
def sleep(dt):
  
  fut = Future('sleep(%.3f)' % dt)
  eventloop.queue_call(dt, fut.set_result, None)
  return fut
408009
def wait(self, timeout=None):
        """"""
        logger = logging.getLogger(__name__)
        if int(self.max_sleep_interval) < int(self._min_sleep_interval):
            self.max_sleep_interval = int(self._min_sleep_interval)
        t0 = time.time()
        sleep_seconds = min(5, self.max_sleep_interval)
        status = self.status
        prev_status = status
        while status < COMPLETED:
            logger.debug("sleep for %d seconds", sleep_seconds)
            time.sleep(sleep_seconds)
            if 2*sleep_seconds <= self.max_sleep_interval:
                sleep_seconds *= 2
            if timeout is not None:
                if int(time.time() - t0) > int(timeout):
                    return
            status = self.status
            if status != prev_status:
                sleep_seconds = min(5, self.max_sleep_interval)
                prev_status = status
947770
public static void sleep(final long durationInMillis) {
		try {
			Thread.sleep(durationInMillis);
		} catch (InterruptedException e) {
			LOG.trace("", e);
			Thread.currentThread().interrupt();
		}
	}
1078847
function _Process_sleep(time)
{
	return __Scheduler_binding(function(callback) {
		var id = setTimeout(function() {
			callback(__Scheduler_succeed(__Utils_Tuple0));
		}, time);

		return function() { clearTimeout(id); };
	});
}
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 );
    }
1244084
@Nonnull
  public static ESuccess sleepSeconds (@Nonnegative final long nSeconds)
  {
    ValueEnforcer.isGE0 (nSeconds, "Seconds");
    return sleep (nSeconds * CGlobal.MILLISECONDS_PER_SECOND);
  }