gh-116738: Make zlib module thread-safe (gh-142432)

Makes the zlib module thread-safe free-threading build. Even though operations
are protected by locks, attributes exposed via PyMemberDef (eof, needs_input,
unused_data, unconsumed_tail) should still be stored atomically within locked
sections, since they can be read without acquiring the lock.

Author: yoney

Lib/test/test_free_threading/test_zlib.py

@@ -0,0 +1,80 @@
+import itertools
+import unittest
+
+from test.support import import_helper, threading_helper
+from test.support.threading_helper import run_concurrently
+
+zlib = import_helper.import_module("zlib")
+
+from test.test_zlib import HAMLET_SCENE
+
+
+NTHREADS = 10
+
+
+@threading_helper.requires_working_threading()
+class TestZlib(unittest.TestCase):
+    def test_compressor(self):
+        comp = zlib.compressobj()
+
+        # First compress() outputs zlib header
+        header = comp.compress(HAMLET_SCENE)
+        self.assertGreater(len(header), 0)
+
+        def worker():
+            # it should return empty bytes as it buffers data internally
+            data = comp.compress(HAMLET_SCENE)
+            self.assertEqual(data, b"")
+
+        run_concurrently(worker_func=worker, nthreads=NTHREADS - 1)
+        full_compressed = header + comp.flush()
+        decompressed = zlib.decompress(full_compressed)
+        # The decompressed data should be HAMLET_SCENE repeated NTHREADS times
+        self.assertEqual(decompressed, HAMLET_SCENE * NTHREADS)
+
+    def test_decompressor_concurrent_attribute_reads(self):
+        input_data = HAMLET_SCENE * NTHREADS
+        compressed = zlib.compress(input_data)
+
+        decomp = zlib.decompressobj()
+        decomp_size_per_loop = len(input_data) // 1000
+        decompressed_parts = []
+
+        def decomp_worker():
+            # Decompress in chunks, which updates eof, unused_data, unconsumed_tail
+            decompressed_parts.append(
+                decomp.decompress(compressed, decomp_size_per_loop)
+            )
+            while decomp.unconsumed_tail:
+                decompressed_parts.append(
+                    decomp.decompress(
+                        decomp.unconsumed_tail, decomp_size_per_loop
+                    )
+                )
+
+        def decomp_attr_reader():
+            # Read attributes concurrently while another thread decompresses
+            for _ in range(1000):
+                _ = decomp.unused_data
+                _ = decomp.unconsumed_tail
+                _ = decomp.eof
+
+        counter = itertools.count()
+
+        def worker():
+            # First thread decompresses, others read attributes
+            if next(counter) == 0:
+                decomp_worker()
+            else:
+                decomp_attr_reader()
+
+        run_concurrently(worker_func=worker, nthreads=NTHREADS)
+
+        self.assertTrue(decomp.eof)
+        self.assertEqual(decomp.unused_data, b"")
+        decompressed = b"".join(decompressed_parts)
+        self.assertEqual(decompressed, HAMLET_SCENE * NTHREADS)
+
+
+if __name__ == "__main__":
+    unittest.main()

Misc/NEWS.d/next/Core_and_Builtins/2025-12-08-14-14-40.gh-issue-116738.x7aaBF.rst

@@ -0,0 +1,2 @@
+Make the attributes in :mod:`zlib` thread-safe on the :term:`free threaded
+<free threading>` build.