Potential race condition in HTTP11Connection._expire_at with GIL disabled

[ismaelorenstein]

Hi,

I'm running httpcore (1.0.9) through httpx (0.28.1) in Python 3.140rc1 free-threaded (ie, with the GIL disabled).

I've noticed an intermittent bug when sending a request in the sync interface:

  File "/home/isma/bigrob/.venv/lib/python3.14t/site-packages/httpx/_client.py", line 1014, in _send_single_request                                                                                                         
    response = transport.handle_request(request)                                                                                                                                                                            
  File "/home/isma/bigrob/.venv/lib/python3.14t/site-packages/httpx/_transports/default.py", line 250, in handle_request                                                                                                    
    resp = self._pool.handle_request(req)                                                                                                                                                                                   
  File "/home/isma/bigrob/.venv/lib/python3.14t/site-packages/httpcore/_sync/connection_pool.py", line 256, in handle_request                                                                                               
    raise exc from None                                                                                                                                                                                                     
  File "/home/isma/bigrob/.venv/lib/python3.14t/site-packages/httpcore/_sync/connection_pool.py", line 228, in handle_request                                                                                               
    closing = self._assign_requests_to_connections()                                                                                                                                                                        
  File "/home/isma/bigrob/.venv/lib/python3.14t/site-packages/httpcore/_sync/connection_pool.py", line 288, in _assign_requests_to_connections                                                                              
    elif connection.has_expired():                                                                                                                                                                                          
         ~~~~~~~~~~~~~~~~~~~~~~^^                                                                                                                                                                                           
  File "/home/isma/bigrob/.venv/lib/python3.14t/site-packages/httpcore/_sync/connection.py", line 190, in has_expired                                                                                                       
    return self._connection.has_expired()                                                                                                                                                                                   
           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^                                                                                                                                                                                   
  File "/home/isma/bigrob/.venv/lib/python3.14t/site-packages/httpcore/_sync/http11.py", line 277, in has_expired                                                                                                           
    keepalive_expired = self._expire_at is not None and now > self._expire_at                                                                                                                                               
                                                        ^^^^^^^^^^^^^^^^^^^^^                                                                                                                                               
TypeError: '>' not supported between instances of 'float' and 'NoneType'        

Seems to be that there is some sort of race condition where the check for self._expire_at is not None initially returns true but then self._expire_at is set to None at handle_request:76 before the now > self._expire_at check runs as that part of the code is not protected by a lock

I did this workaround here and it is now working:

    def has_expired(self) -> bool:
        now = time.monotonic()
        with self._state_lock:                       # NEW
            keepalive_expired = self._expire_at is not None and now > self._expire_at

        # If the HTTP connection is idle but the socket is readable, then the

Thanks for the awesome library. I wasn't able to isolate the issue in a reproductible snippet yet but let me know if you need it.

[TayfurYldz]

The race in the report is consistent with current main.

handle_request() clears self._expire_at while holding _state_lock, but has_expired() currently reads it outside that lock:

keepalive_expired = self._expire_at is not None and now > self._expire_at

Under the GIL that compound expression effectively got more serialization than the code actually guarantees. In a free-threaded build, another thread can set _expire_at = None between those two attribute reads, producing exactly the reported float > None failure.

The lock-based workaround is therefore correct in principle, but the critical section can stay very small: take _state_lock, snapshot _expire_at (and, ideally, the state needed for the idle/readable check), then make the comparisons from those local values. That gives has_expired() one coherent view of the connection state without holding the lock while querying the network stream.

I would also audit the equivalent state-inspection methods rather than fixing only this expression. Free-threading turns previously-benign repeated attribute reads into real synchronization points, and the invariant here is that pool-facing state queries should observe a coherent state transition.

A regression test does not need to rely on winning a probabilistic race: a test double or synchronization barrier can pause between the relevant state observations while another thread starts a request, making the old implementation deterministically exercise the invalid transition.