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:
<?php
$sleepuntil = strtotime("tuesday 3pm");
while (time() < $sleepuntil)
time_sleep_until($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.
time_sleep_until
(PHP 5 >= 5.1.0, PHP 7, PHP 8)
time_sleep_until — Lässt das Skript bis zur angegebenen Zeit schlafen
Beschreibung
Lässt das Skript bis zum angegebenen timestamp
schlafen.
Parameter-Liste
-
timestamp -
Der Unix-Timestamp, zu dem die Ausführung des Skripts wieder aufgenommen werden soll.
Rückgabewerte
Gibt bei Erfolg true zurück. Bei einem Fehler wird false zurückgegeben.
Fehler/Exceptions
Die Funktion generiert eine E_WARNING-Meldung, wenn
der angegebene timestamp in der Vergangenheit liegt.
Beispiele
Beispiel #1 Ein time_sleep_until()-Beispiel
<?php
// Gibt false zurück und generiert eine Warnung
var_dump(time_sleep_until(time()-1));
// funktioniert evtl. nur auf schnellen Rechnern, schläft für bis zu 0.2 Sekunden
var_dump(time_sleep_until(microtime(true)+0.2));
?>Anmerkungen
Hinweis: Alle eingetroffenen Signale werden erst ausgeliefert, wenn die Ausführung fortgesetzt wird.
Siehe auch
- sleep() - Verzögert die Programmausführung
- usleep() - Verzögert die Programmausführung (in Mikrosekunden)
- time_nanosleep() - Verzögert die Ausführung um die gegebene Anzahl Sekunden und Nanosekunden
- set_time_limit() - Beschränkt die maximale Ausführungszeit
add a note
User Contributed Notes 3 notes
purdue at nc dot rr dot com ¶
13 years ago
rowan dot collins at cwtdigital dot com ¶
12 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.
<?php
/**
* 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;
# DO STUFF THAT MAY OR MAY NOT TAKE VERY LONG
sleep_until( $minimum_start_of_next_loop, $min_pause_between_loops );
}
</code>
*/
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 );
}
else
{
// Sleep for the number of seconds until the target time
sleep( $time_to_target );
}
}
?>
divinity76 at gmail dot com ¶
5 years ago
if you for some reason need a constant-time implementation of realpath(), try
<?php
function realpath_constant_time(string $path, float $target_seconds, bool &$constant_time_success = null){
$start_time=microtime(true);
$ret=realpath($path);
$constant_time_success = @time_sleep_until($start_time+$target_seconds);
return $ret;
}
?>
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):
<?php
realpath_constant_time("/path/to/../to/file.txt",0.001,$constant_time_success);
?>
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.
