PHP 8.1.20 Released!


(PHP 5 >= 5.1.0, PHP 7, PHP 8)

time_sleep_until Paralisa o script até um tempo especificado


time_sleep_until(float $timestamp): bool

Paralisa o script até o especificado timestamp.



O timestamp quando o script deve voltar.

Valor Retornado

Retorna true em caso de sucesso ou false em caso de falha.


Se o especificado timestamp é do passado, esta função irá gerar um E_WARNING.


Exemplo #1 Um exemplo da time_sleep_until()


//returns false and generates a warning

// may only work on faster computers, will sleep up to 0.2 seconds



Nota: Todos sinais serão enviados depois do script voltar.

Nota: Esta função não foi implementada na plataforma Windows.

Veja Também

  • sleep() - Atrasa a execução do script
  • usleep() - Atrasa a execução em milionésimos de segundo
  • time_nanosleep() - Atrasa para um número de segundos e nanosegundos

add a note

User Contributed Notes 3 notes

purdue at nc dot rr dot com
12 years ago
At least on my Windows machine, the time_sleep_until function appears to calculate the number of microseconds between now and the sleep-until timestamp, and it appears to use unsigned 32-bit math in this calculation.  This roundoff leads to a maximum sleep time of just under 4295 seconds (1 hour, 11 minutes, 35 seconds).  To get longer sleep times, while still using time_sleep_until to minimize processor overhead, the following loop may be some help to you:


= strtotime("tuesday 3pm");

while (
time() < $sleepuntil)

// proceed with dated processing


Of course, one could use something like "cron" instead, to avoid the script doing the extended sleep.  Also note that time_nanosleep appears to do similar math, but it is somewhat more intuitive that the seconds parameter has an upper limit on what it can be.  Still, both functions might report a warning when waking up prematurely due to roundoff.
rowan dot collins at cwtdigital dot com
11 years ago
Not realising that this function existed, I wrote something similar, but it has the additional facility to specify a minimum pause even if the target time has already been reached, for instance in a processor-intensive loop.

It's in seconds rather than microseconds (it's intended for heavy-duty CLI scripts), but that could easily be changed by using microtime(true) and usleep if greater granularity was required.

     * Pause processing until the specified time, to avoid hammering a DB or service
     * @param int $target_time Timestamp
     * @param int $min_sleep Always sleep for a minimum number of seconds,
     *    even if the target timestamp has already passed.
     *     Default 0, meaning only sleep until the target timestamp is reached.
     * @example <code>
         while ( ! $finished )
             $minimum_start_of_next_loop = time() + $min_secs_per_loop;
             sleep_until( $minimum_start_of_next_loop, $min_pause_between_loops );
function sleep_until($target_time, $min_sleep = 0)
$time_now = time();
$time_to_target = $target_time - $time_now;
// If we've already reached the target time, that's fine
if ( $time_to_target <= $min_sleep )
// If required, sleep for a bit anyway
sleep( $min_sleep );
// Sleep for the number of seconds until the target time
sleep( $time_to_target );
divinity76 at gmail dot com
3 years ago
if you for some reason need a constant-time implementation of realpath(), try


function realpath_constant_time(string $path, float $target_seconds, bool &$constant_time_success = null){
$constant_time_success = @time_sleep_until($start_time+$target_seconds);

for example, a realtime that always uses exactly 1 millisecond (should be more than enough for SSD-based servers, perhaps rotating harddrive based servers may need something closer to 10 milliseconds, i don't know):


and you can use $constant_time_success to see if you needed more time (and thus failed to do realpath() in constant-time), or if you succeeded.
To Top