usleep

(PHP 3, PHP 4, PHP 5)

usleep -- Delay execution in microseconds

Description

void usleep ( int micro_seconds )

The usleep() function delays program execution for the given number of micro_seconds. A microsecond is one millionth of a second.

例子 1. usleep() example

<?php

// Current time
echo date('h:i:s') . "\n";

// wait for 2 secondes
usleep(2000000);

// back!
echo date('h:i:s') . "\n";

?>

This script will output :

11:13:28
11:13:30

注: This function did not work on Windows systems until PHP 5.0.0

See also sleep() and set_time_limit().


add a note add a note User Contributed Notes
Rasmus Schultz
23-Aug-2006 09:39
I have spent DAYS trying to create a reliable usleep()-replacement for Windows.

I have only this to offer:

As commented by someone else already, the gettimeofday() method used below is useless - PHP will use all available CPU power doing nothing.

The fsockopen() method apparently is also useless - as someone else commented, an fclose() was missing in the original post, but this apparently does not solve the problem. After calling the function about 50 or so times, fsockopen() returns immidiately, without any delay - and watching a process monitor in Windows, you can then watch the process taking up increasingly more memory, until eventually PHP aborts (or crashes) when it reaches maximum.

The win32api-method is also a no-go ... after calling the Sleep function a few hundred times (during which memory usage will also go up every time due to a memory leak somewhere), PHP will cause an exception and Windows will terminate it.

I have given up - I don't think there is any viable solution to this problem under PHP 4.

If you need this function, upgrade your project to PHP 5.

Or settle for 1-second delays with the sleep()-function.

These, unfortunately, seem to be your only options...
Patrick
27-Jul-2006 04:04
I want to create a daemon/Linux service. Here is an example of how to run a process that has "throttle control"

// You must set these
//
// max_execution_time = 0
// max_input_time = 0

function doProcess() {
   echo "Start"."\n";
   usleep(10000);
   echo "Stop"."\n";
   return false;
}

function manageProcess() {
   // Setup data
   $runsPerMinute = 200;
   $maxMinuteAverage = 5;
   $waitIfNotWorking = 120; // seconds

   // Conversion
   $microsPerSecond = 1000000;

   // Statistical Info
   $currentMinute = 0;
   $minute = -1;
   $countPerMinute = array();
   $sumPerMinute = array();

   // Totals
   $totalProcessTime = 0;
   $totalCounts = 0;

   while (true) {
       $timestart = microtime();
       $performedWork = doProcess();
       $timeend = microtime();

       if (!$performedWork) {
           // Statistical Info
           $currentMinute = 0;
           $minute = -1;
           $countPerMinute = array();
           $sumPerMinute = array();

           sleep($waitIfNotWorking);
       } else {

           $ts = split(" ",$timestart);
           $te = split(" ",$timeend);

           $te[0] = ($te[0] * $microsPerSecond) - ($ts[0] * $microsPerSecond);
           $te[1] = ($te[1] - $ts[1]) * $microsPerSecond;

           $processTime = $te[0] + $te[1];

           if (date("i")<>$minute) { // We are NOT in the same minute
               // Reset the new minute
               $minute = date("i");
               $currentMinute = ($currentMinute+1) % $maxMinuteAverage;

               // Remove Statistical Information from the minute we are expiring.
               if (isset($countPerMinute[$currentMinute])) {
                   $totalProcessTime = $totalProcessTime - $sumPerMinute[$currentMinute];
                   $totalCounts = $totalCounts - $countPerMinute[$currentMinute];
               }

               $countPerMinute[$currentMinute] = 0;
               $sumPerMinute[$currentMinute] = 0;
           }

           $countPerMinute[$currentMinute] = $countPerMinute[$currentMinute] + 1;
           $sumPerMinute[$currentMinute] = $sumPerMinute[$currentMinute] + $processTime;

           $totalCounts = $totalCounts + 1;
           $totalProcessTime = $totalProcessTime + $processTime;

           $averageRuntime = round($totalProcessTime / $totalCounts);

           $waitTime = (($microsPerSecond*60) / $runsPerMinute) - $averageRuntime;

           usleep($waitTime);
       }
   }

}

manageProcess();
gizmo at aoaforums dot com
03-Feb-2006 01:28
It should be noted that Windows machines have a resolution of either 10 mS or 15 mS (depending on the chipset implementation and HAL used) when using the Sleep() function in kernel32.dll.  This means that your average error will be either 5 or 7.5 mS.  This is not ordinarily a problem unless you really NEED to sleep for less time than the granularity provided by Windows.
gmc at serveisw3 dot net
08-Jul-2005 12:11
If you're using Windows then you maybe are in trouble with usleep if you really need to use it.

The Bernie's microdelay function using fsockopen does not work properly, and the fclose doesn't help much.

I don't know if network connections go strange, but I know it does not work since you've made more than 2000 - 3000 calls to it, so it's not a reliable solution in 'long life' php scripts, or these are the issues of the microdelay function in my PHP and PHP-GTK applications.

Though another solution should be found, and googling a bit I fount a WinAPI function: Sleep.

So I get with this snippet wich works fine for me, you get milliseconds precission but the more important, it works for long-run scripts and of course, it does not waste any CPU cycles.

dl('php_w32api.dll');

$GLOBALS['win32api'] =& new win32;

// USleep alternative for Windows and PHP4:
$GLOBALS['win32api']->registerfunction("long Sleep (long dwMillisecods) From kernel32.dll");

// Now you can call the function from everywhere in your script: $GLOBALS['win32api']->Sleep(milliseconds);

for ($msec = 2000; $msec > 0; $msec = $msec - 125) {
  echo "Hi. Next one in $msec msec.\n";
  $GLOBALS['win32api']->Sleep($msec);
}
t0russ at gmail dot com
03-May-2005 11:06
solution to the warning posted by Bertie:
$f=@fsockopen("tcp://localhost",$UNUSED_PORT,$errno,$errstr,$delay);
@fclose($f);
brian dot hollenbeck at gmail dot com
25-Mar-2005 08:28
Just a tip for the folks at home: is you use multiple rand() functions in your code, be sure to put a randomized usleep() in between the rand() codelines, or else your "random" seeds won't be so random on a fast server.

Example:

$string = rand(0, 100);
$string = rand(0, 200);

Instead:

$string = rand(0, 100);
usleep(rand(1000, 10000));
$string1 = rand(0, 100);
Bertie
29-Nov-2003 03:47
A word of warning about the microdelay() code posted that uses the fsockopen - if you use this is a loop that delays for small periods you will very quickly run out of sockets/socket buffer space. And then your network connections go very strange......
grail dot ink at unix dot net
29-Aug-2003 05:06
We have developed an alternative to usleep that should work on any platform and it doesn't eat up any CPU cycles. It's been tested on Windows 2000 w/ Apache. Other platforms should work fine.

function microdelay($delay) {
$UNUSED_PORT=31238; //make sure this port isn't being used on your server
@fsockopen("tcp://localhost",$UNUSED_PORT,$errno,$errstr,$delay);
}

It times out after a specified time in seconds. It uses a double as argument so you can specify decimal arguments.

microdelay(.5); //500ms
microdelay(.25); //250ms
microdelay(2.25); //2250ms

Our small contribution to this great language!

http://www.xencoders.com
jadd0r at mail dot com
09-Apr-2003 01:59
You could do neat things with this like for unix:

<?php
$y
=1000000;
for (
$x=1; $x<50; $x++) {
echo
chr(7);
usleep($y*(pow(0.9,$x)+0.2));
}
?>

then execute
`php -q script.php > /dev/console`

will result in a bombtimer (chr(7) is beep character) :]
busby at edoceo dot com
18-Jan-2003 08:04
Should be noted that functions that loop really fast to create a delay also consume 100% CPU while doing the loop.  Try creating a dummy loop that goes 100000 times, watch it choke your machine.  If you really need usleep() don't use windows.
dsc at c2i dot net
15-Mar-2002 01:55
The usleep() for Windows above doesn't take into account that the value of $stop can be lower than $start. It also contains unnecessary casts and $temp variable. Here is a better function:

function usleepWindows($usec)
{
   $start = gettimeofday();

   do
   {
       $stop = gettimeofday();
       $timePassed = 1000000 * ($stop['sec'] - $start['sec'])
           + $stop['usec'] - $start['usec'];
   }
   while ($timePassed < $usec);
}
dave at techweavers dot net
29-Dec-2000 11:29
To monitor a scripts CPU ussage and avoid any nasty CPU gobbling loops you can use this function (will not work with windows or safe mode) I know it works on FreeBSD:
function phpmon($max)
 {
 $cmd = `ps -Unobody -r -o%cpu`;
 $lines = explode("\n", $cmd);
 $usage = substr($lines[1], 0, strpos($lines[1], "."));
 $sleeprate = 500;
 while ($usage >= $max)
  {
  $cmd = `ps -Unobody -r -o%cpu`;
  $lines = explode("\n", $cmd);
  $usage = substr($lines[1], 0, strpos($lines[1], "."));
  usleep($sleeprate);
  }
 }

phpmon($MAX);

where $MAX is the maximum CPU you want the process to consume. e-mail me with any improvements/suggestions.

I have noticed that this consumes a lot of system CPU (at least in my limited testing) possibly from all of the system calls or the huge mathematical functions I used to test the effectiveness of the script.