Make cross-thread locks use native blocking and timeouts instead of spinning.

jamadden · jamadden · commit e0d97051f43e · 2024-02-13T16:07:48.000-06:00
This may improve scenarios like #2013
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -517,11 +517,6 @@ jobs:
           GEVENT_MANYLINUX_NAME: ${{ matrix.image }}
 
         run: scripts/releases/make-manylinux
-      - name: Upload gevent wheels
-        uses: actions/upload-artifact@v4
-        with:
-          path: wheelhouse/*whl
-          name: ${{ matrix.config[2] }}_x86_64_wheels.zip
       - name: Publish package to PyPI
         uses: pypa/gh-action-pypi-publish@v1.4.1
         if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags')
@@ -530,6 +525,11 @@ jobs:
           password: ${{ secrets.TWINE_PASSWORD }}
           skip_existing: true
           packages_dir: wheelhouse/
+      - name: Upload gevent wheels
+        uses: actions/upload-artifact@v4
+        with:
+          path: wheelhouse/*whl
+          name: ${{ matrix.image }}_wheels.zip
 
 # TODO:
 # * Use YAML syntax to share snippets, like the old .travis.yml did
diff --git a/docs/changes/2020.bugfix b/docs/changes/2020.bugfix
@@ -19,3 +19,8 @@ Other changes:
 - Drop ``setuptools`` to a soft test dependency.
 - Drop support for very old versions of CFFI.
 - Update bundled c-ares from 1.19.1 to 1.26.0.
+- Locks created by gevent, but acquired from multiple different
+  threads (not recommended), no longer spin to implement timeouts
+  and interruptible blocking. Instead, they use the native
+  functionality of the Python 3 lock. This may improve some scenarios.
+  See :issue:`2013`
diff --git a/src/gevent/_semaphore.py b/src/gevent/_semaphore.py
@@ -77,6 +77,10 @@ class Semaphore(AbstractLinkable): # pylint:disable=undefined-variable
     .. versionchanged:: 20.12.0
        Improved support for multi-threaded usage. When multi-threaded usage is detected,
        instances will no longer create the thread's hub if it's not present.
+
+    .. versionchanged:: NEXT
+       Uses Python 3 native lock timeouts for cross-thread operations instead
+       of spinning.
     """
 
     __slots__ = (
@@ -449,22 +453,16 @@ def __acquire_without_hubs(self, timeout):
                     return False
 
     def __spin_on_native_lock(self, thread_lock, timeout):
-        expiration = 0
-        if timeout:
-            expiration = monotonic() + timeout
-
         self._drop_lock_for_switch_out()
         try:
-            # TODO: When timeout is given and the lock supports that
-            # (Python 3), pass that.
-            # Python 2 has terrible behaviour where lock acquires can't
-            # be interrupted, so we use a spin loop
-            while not thread_lock.acquire(0):
-                if expiration and monotonic() >= expiration:
-                    return False
-
-                _native_sleep(0.001)
-            return True
+            # Unlike Python 2, Python 3 thread locks
+            # can be interrupted when blocking, with or
+            # without a timeout. Python 2 didn't even
+            # support a timeout for non -blocking.
+            if timeout:
+                return thread_lock.acquire(True, timeout)
+
+            return thread_lock.acquire()
         finally:
             self._acquire_lock_for_switch_in()
 
