To implement state polling for asynchronous tasks in PHP, you can use a while loop in conjunction with the usleep function for safe timing checks. 1. Basic implementation: Check the task status by calling getJobStatus a loop, set the maximum number of attempts (such as 60 times) and the interval time (such as 50ms), and exit the loop when the task completes, fails or timeouts. 2. Set the polling interval reasonably: It is recommended to use 100ms (100,000 microseconds) as the initial value to avoid overloading the system or over-long affecting the response speed. 3. Best practices include: the maximum number of attempts must be set to prevent infinite loops; proper handling of temporary failures such as network exceptions to avoid interrupt polling; logs should be recorded or downgrade processing should be triggered when timeout; long polling should be avoided in web requests as much as possible. If necessary, set_time_limit and ignore_user_abort should be called to extend execution time and prevent user interruptions; the better solution is to return the task ID and poll it through AJAX by the front end, or use queue systems such as Laravel Queues. 4. Sample scenario: Get task status from Redis, loop check until completion, error or timeout. In short, while plus usleep is suitable for simple polling requirements in CLI scripts, but in scenarios where high concurrency or real-time requirements are high, more efficient alternatives such as WebSocket, SSE or message queues should be considered. This method is simple and reliable, but attention should be paid to resource consumption and timeout control to ensure system stability.

When dealing with asynchronous tasks in PHP—like processing uploads, generating reports, or waiting for external API callbacks—you often need to check the status of a background job until it completes. One straightforward way to implement this is using a while loop combined with usleep for controlled polling. This approach is useful in CLI scripts or long-running web contexts where you can't rely on real-time notifications (eg, webhooks).

Here's how to do it effectively and safely.

1. Basic Asynchronous Polling with while and usleep

The core idea is to repeatedly check a condition (eg, job completion) in a loop, pausing between checks to avoid overwhelming the system.

 $jobId = 'abc123'; // Assume this was enqueued earlier
$pollInterval = 50000; // 50ms in microseconds
$maxAttempts = 60; // Max 60 attempts = ~3 seconds total
$attempts = 0;

while ($attempts < $maxAttempts) {
    $status = getJobStatus($jobId); // Your function to check status

    if ($status === &#39;completed&#39;) {
        echo "Job completed successfully.\n";
        break;
    }

    if ($status === &#39;failed&#39;) {
        echo "Job failed.\n";
        break;
    }

    // Wait before next poll
    usleep($pollInterval);
    $attempts ;
}

if ($attempts >= $maxAttempts) {
    echo "Job timed out.\n";
}

In this example:

• usleep(50000) pauses the script for 50 million seconds.
• We limit the number of attempts to avoid infinite loops.
• The loop exits when the job succeeds, fails, or times out.

2. Choosing the Right Polling Interval

The value passed to usleep() is in microseconds :

• 1 second = 1,000,000 microseconds
• Common intervals:
  • 50000 = 50ms
  • 100000 = 100ms
  • 500000 = 500ms

Too short an interval (eg, 10ms) can:

• Overload the database or API
• Waste server resources
• Trigger rate limits

Too long an interval (eg, 2 seconds) can:

• Delay detection of job completion
• Make the system feel sluggish

Recommendation: Start with 100ms ( 100000 ) for most use cases.

3. Best Practices and Safety Tips

? Use a maximum attempt limit

Always prevent infinite loops by capping retries.

? Handle transient failures gracefully

Network issues or temporary errors should not crash your polling loop.

 $status = getJobStatus($jobId);

if ($status === false) {
    // eg, API timeout
    usleep($pollInterval);
    $attempts ;
    continue;
}

? Clean up or notify on timeout

Don't just exit silently. Log the event or trigger a fallback.

? Avoid in web requests when possible

Long-running loops in web scripts can:

• Hit PHP's max_execution_time
• Block web servers
• Cause poor UX

Better alternatives:

• Return a job ID and let the frontend poll via AJAX
• Use a queue worker (eg, with Laravel Queues or Symfony Messenger)

But if you must do it in a web context, increase limits:

 set_time_limit(30); // Allow up to 30 seconds
ignore_user_abort(true); // Continue even if user closes browser

4. Example: Polling a Redis-Backed Job Queue

Suppose you're using Redis to store job status:

 function getJobStatus($jobId) {
    $redis = new Redis();
    $redis->connect('127.0.0.1', 6379);
    return $redis->get("job:$jobId:status");
}

$jobId = 'task_789';
$attempts = 0;
$maxAttempts = 20;
$interval = 100000; // 100ms

while ($attempts < $maxAttempts) {
    $status = getJobStatus($jobId);

    if ($status === &#39;done&#39;) {
        echo "Success!\n";
        break;
    }

    if ($status === &#39;error&#39;) {
        echo "Job errored.\n";
        break;
    }

    usleep($interval);
    $attempts ;
}

if ($attempts === $maxAttempts) {
    echo "Job did not complete in time.\n";
}

Final Notes

While while usleep is simple and works well in CLI scripts (eg, cron jobs or queue workers), it's not ideal for real-time web applications . For better scalability, consider:

• WebSockets (via Ratchet, Swoole, etc.)
• Server-Sent Events (SSE)
• Client-side AJAX polling
• Message brokers (RabbitMQ, Kafka)

But for lightweight, synchronous-style waiting in background scripts, usleep -based polling is a practical and easy-to-debug solution.

Basically, keep it simple, set limits, and avoid over-polling.

The above is the detailed content of Implementing Asynchronous Task Polling with PHP `while` Loops and `usleep`. For more information, please follow other related articles on the PHP Chinese website!