Concurrent Requests

Thanks to responses being lazy,requestsare always managed concurrently.

On a fast enough network, the following code makes 379 requests inless than

Symfony's HTTP client makes asynchronous HTTPrequestsby default. This means

you don't need to configure anything special to send multiple requests inparallel

Here's a practical example that fetches metadata about several Symfony

components from the Packagist API in parallel::

As you canreadin the first"for"loop,requests are issuedbutare not consumed

yet. That'sthetrick when concurrency isdesired: requests should be sent

the above "foreach" loop.

As you cansee, the requests are sentin the first loop, buttheir responses

aren't consumed untilthesecond one. This isthe key to achieving parallel and

code waits only when necessary.

..note::

The maximum number of concurrent requeststhat you can perform depends on

the resources of your machine(e.g.your operating systemmay limit the

file). Make yourrequests in batches to avoid these issues.

The maximum number of concurrent requestsdepends on your system's resources

(e.g.the operating systemmight limit the number of simultaneous connections

processingrequests in batches.

Multiplexing Responses

If you look again at the snippet above, responses are read in requests' order.

But maybe the 2nd response came back before the 1st? Fully asynchronous operations

require being able to deal with the responses in whatever order they come back.

In the previous example, responses are read in the same order as the requests

were sent. However, it's possible that, for instance, the second response arrives

before the first. To handle such cases efficiently, you need fully asynchronous

processing, which allows responses to be handled in whatever order they arrive.

In order to do so, the

:method:`Symfony\\Contracts\\HttpClient\\HttpClientInterface::stream`

acceptsa list of responses to monitor. As mentioned

To achieve this, the

:method:`Symfony\\Contracts\\HttpClient\\HttpClientInterface::stream` method

can be used to monitora list of responses. As mentioned

:ref:`previously<http-client-streaming-responses>`, this method yields response

chunks as they arrivefrom the network.By replacingthe"foreach" in the

snippet withthis one, the code becomes fully async::

chunks assoon asthey arriveover the network.Replacingthestandard ``foreach``

loop withthe following version enables true asynchronous behavior::

..tip::

Use the ``user_data`` optioncombined with ``$response->getInfo('user_data')``

totrack the identity of the responses in your foreach loops.

Use the ``user_data`` optionalong with ``$response->getInfo('user_data')``

toidentify each response during streaming.

Dealing with Network Timeouts