Is httpx.Client thread safe?

[pfmoore]

I'm writing a multi-threaded application that makes HTTP requests. The way I have my code structured, I'd like to share a single httpx.Client instance between my worker threads. Is that possible? I've looked through the docs, and I can't see any information on thread safety.

I could probably structure my code to use a client per worker (or maybe I'd need to do one per connection if I can't work out how to add setup code to concurrent.futures workers), but as I'm fetching a load of files from a single server, sharing a client seems like it would be better for performance.

Just for completeness, I'll note that I can't use async, because one of my classes needs a sync interface.

[tomchristie]

Yes. HTTPX is intended to be thread-safe, and yes, a single client-instance across all threads will do better in terms of connection pooling, than using an instance-per-thread.

We might want to figure a good place in the docs to write about this. (?)

I've not looked through requests or urllib3 to see where they choose to discuss this in their own docs. Their docs choices here might be a useful pointer for us.

(And thank you for the clearly framed question, much appreciated 💚)

[pfmoore]

Thanks for the quick reply! For what it's worth, requests doesn't say much - from a search, an older version of the docs seems to have had "Thread safe" in the features list but it's missing from the latest version...

If it helps, the two places I looked where I would have hoped to find something were:

• The Client class documentation. If the summary said "An HTTP client, with connection pooling, HTTP/2, redirects, cookie persistence, etc. Can be shared between threads." that would have been sufficient for me.
• For more detailed information, I looked in the "Advanced Usage" section for a "Thread Safety" section. That might be overkill if all there is to say is "yes, it should be fine" though 🙂

[erdnaxeli]

Hi, is the same true with the async interface? Can I use the same (async) client in concurrent tasks?

[tomchristie]

Yes. HTTPX is thread and task safe. Looks like we oughta be highlighting that in the docs.

[lee-cq]

For AyncClient, it is thread-safe, but it is worth noting that the connection pool cannot be shared among multiple Event Loops.

So if you use the same asynchronous client in multiple Event Loops, you may need to disable connection pooling, otherwise you will encounter some problems (eg. #2959).

[tomchristie]

if you use the same asynchronous client in multiple Event Loops, you may need to disable connection pooling

That's not quite the correct synopsis here, no.
Rephrase that to "don't use an asynchronous client in multiple Event Loops".

(It will typically just error if you do, but it'd be neater if we outright prevented it.)

[steve-mavens]

For what it's worth, this is currently the top hit on Google for "httpx thread safety", which arguably is worth as much as finding the right place for it in the docs!

[cosven]

I doubt that there are race conditions in Client code

Think about this case

1. thread A calls Client.send method and it stops at L888
2. thread B calls Client.close method and it stops at L1257
3. thread A continues to run and it turns client.state to OPENED

In this case, thread A tries to send a request on an already-closed client.

Client.close method

httpx/httpx/_client.py

Lines 1251 to 1261 in 87f39f1

	def close(self) -> None:
	"""
	Close transport and proxies.
	"""
	if self._state != ClientState.CLOSED:
	self._state = ClientState.CLOSED
	self._transport.close()
	for transport in self._mounts.values():
	if transport is not None:
	transport.close()

Client.send method

httpx/httpx/_client.py

Lines 888 to 892 in 87f39f1

	"""
	if self._state == ClientState.CLOSED:
	raise RuntimeError("Cannot send a request, as the client has been closed.")
	self._state = ClientState.OPENED

[tomchristie]

Muhuh. Yeah you probs can close the client like that, with the not-very-terrible outcome that the transport will raise an exception indicating that it's been closed.

We could have threading locks around the close/open state, but I'd prefer we don't. (Or rather I'd prefer we don't at this layer. We do at the transport layer.) Adding those would be overkill.

[cosven]

Or rather I'd prefer we don't at this layer. We do at the transport layer.

From another perspective, can we say that it is not very good to maintain the open/close state on the Client level.

[karpetrosyan]

By saying httpx is thread-safe and task-safe, we should understand that we can do as many requests as we want concurrently, and it's not going to break the client state, which is true.

Closing the client in one thread and making requests in another would probably break the client state, as you mentioned.
Although this is not really how httpx is used, we can discuss handling such cases in httpx.

In most cases, you simply create a client instance locally or globally, make concurrent requests, and then close it.