Naively awaiting inside loops in async PHP causes sequential execution, defeating concurrency; 2. In Amp, use Amp\Promise\all() to run all operations in parallel and wait for completion, or Amp\Iterator\fromIterable() to process results as they arrive; 3. In ReactPHP, use React\Promise\all() for parallel execution or PromiseMap::map() with concurrency limits to control simultaneous operations; 4. Always avoid blocking inside loops, handle errors with appropriate promise combinators, manage backpressure by streaming results, and prefer awaiting the entire operation instead of individual tasks to maintain performance and control flow.

When working with asynchronous PHP frameworks like Amp or ReactPHP, one of the biggest mental shifts from traditional PHP is how you handle loops — especially when dealing with asynchronous operations inside them. In synchronous PHP, a foreach loop is straightforward: run some code for each item, one after another. But in async contexts, naively awaiting inside a loop can lead to unexpected performance bottlenecks or even broken control flow.

Let’s break down how to properly handle asynchronous iteration in Amp and ReactPHP, and why the usual approaches don’t always work.

Why Regular Loops Fail in Async Code

In synchronous PHP, you might write:

foreach ($urls as $url) {
    $result = file_get_contents($url);
    echo $result;
}

But in async code, if you try this:

// DON'T DO THIS
foreach ($urls as $url) {
    $result = yield $httpClient->request($url); // Amp
    echo $result;
}

You're awaiting each request sequentially — the next request won’t start until the previous one finishes. That kills the benefit of concurrency.

Even worse: in ReactPHP, you can’t yield at all, and blocking waits aren’t allowed. You’d need to chain then() callbacks — which quickly becomes unmanageable in loops.

Handling Async Iteration in Amp

Amp provides tools to manage async iteration properly. The key is to avoid yielding inside the loop body and instead start all operations concurrently, then wait for them.

Use Amp\Promise\all() for Parallel Execution

use Amp\Promise;
use Amp\Http\Client\Client;
use Amp\Http\Client\Request;

$promises = [];

foreach ($urls as $url) {
    $promises[] = Amp\call(fn () => $httpClient->request($url)->getBody());
}

$results = yield Promise\all($promises);

foreach ($results as $result) {
    echo $result;
}

This starts all HTTP requests in parallel, then waits for all to complete.

? Best for: when you want all items processed and can wait for the slowest.

Use Amp\Iterator for Streamed Results

If you want to process results as they arrive, use Amp\ConcurrentIterator:

$promises = [];
foreach ($urls as $url) {
    $promises[] = Amp\call(fn () => $httpClient->request($url)->getBody());
}

$iterator = Amp\Iterator\fromIterable($promises);

while (yield $iterator->advance()) {
    $result = $iterator->getCurrent();
    echo "Got: $result\n";
}

This outputs results as soon as each promise resolves, without waiting for all.

Handling Async Iteration in ReactPHP

ReactPHP uses callbacks and React\Promise\PromiseInterface. There’s no yield, so you build promise chains or use utility functions.

Use React\Promise\all() for Parallel Execution

use React\Promise;

$promises = [];

foreach ($urls as $url) {
    $promises[] = $httpClient->request('GET', $url)->then(
        fn ($response) => $response->getBody()->getContents()
    );
}

Promise\all($promises)->then(function ($results) {
    foreach ($results as $result) {
        echo $result;
    }
});

Like Amp’s all(), this runs everything in parallel and resolves when all finish.

? Good for batch processing, but blocks output until the last item.

Use React\Promise\some() or map() for More Control

For processing with limits (e.g., max 3 concurrent), use clue/reactphp-mq or react/promise-maps (third-party):

use React\Promise\PromiseMap;

$results = PromiseMap::map($urls, function ($url) use ($httpClient) {
    return $httpClient->request('GET', $url)
        ->then(fn ($res) => $res->getBody()->getContents());
}, ['concurrency' => 3]);

$results->then(function ($bodies) {
    foreach ($bodies as $body) {
        echo $body;
    }
});

This limits concurrency to 3 requests at a time — ideal for avoiding overwhelming servers.

Key Takeaways

• ? Never yield or block inside a loop expecting concurrency.
• ? Use Promise\all() when you need all results and can wait.
• ? Use streaming iterators (Amp) or map() with concurrency limits (ReactPHP) for better flow control.
• ? Process results as they arrive when possible — improves responsiveness.
• ?? Beware of memory: buffering thousands of promises can be expensive.

For real-world use, consider:

• Error handling: Use Promise\any(), some(), or wrap in try/catch (Amp) or .catch() (ReactPHP).
• Backpressure: Stream results instead of collecting everything.
• Cancellation: Amp supports cancelable promises; ReactPHP less so.

Async iteration isn’t about replacing foreach — it’s about rethinking when and how you wait.

Basically, don’t loop to await — await the loop.

The above is the detailed content of Asynchronous Iteration: A Look at Loops in an Amp or ReactPHP Context. For more information, please follow other related articles on the PHP Chinese website!