Fix GC-induced thread hang on macOS with Python 3.14

   Python 3.14 sets the gen-2 GC threshold to 0, so long-lived objects
   (like SChunk instances in pytest fixtures) never get auto-collected.
   Each SChunk carries 2×nthreads OS pthreads via its cctx/dctx. During
   pytest teardown, thousands of accumulated SChunks hit macOS's 6144
   thread limit, causing an indefinite hang on gc.collect().

   Three fixes applied:

   - Release the GIL during blosc2_schunk_free() in SChunk.__dealloc__
     to prevent GIL deadlock when mass finalization triggers pthread_join

   - Add periodic gc.collect() every 50 tests in conftest.py to prevent
     thread accumulation past the macOS ceiling

   - Cap ThreadPoolExecutor in lazyexpr.py to os.cpu_count() workers
     (fixes #556)

   Closes #556

Author: FrancescAlted

src/blosc2/blosc2_ext.pyx

@@ -476,7 +476,7 @@ cdef extern from "blosc2.h":
     int64_t blosc2_schunk_to_buffer(blosc2_schunk* schunk, uint8_t** cframe, c_bool* needs_free) nogil
     void blosc2_schunk_avoid_cframe_free(blosc2_schunk *schunk, c_bool avoid_cframe_free)
     int64_t blosc2_schunk_to_file(blosc2_schunk* schunk, const char* urlpath)
-    int64_t blosc2_schunk_free(blosc2_schunk *schunk)
+    int64_t blosc2_schunk_free(blosc2_schunk *schunk) nogil
     int64_t blosc2_schunk_append_chunk(blosc2_schunk *schunk, uint8_t *chunk, c_bool copy)
     int64_t blosc2_schunk_update_chunk(blosc2_schunk *schunk, int64_t nchunk, uint8_t *chunk, c_bool copy)
     int64_t blosc2_schunk_insert_chunk(blosc2_schunk *schunk, int64_t nchunk, uint8_t *chunk, c_bool copy)
@@ -2339,14 +2339,23 @@ cdef class SChunk:
             self.schunk.cctx = NULL
 
     def __dealloc__(self):
+        cdef blosc2_schunk *schunk_ptr
         if self.schunk != NULL and not self._is_view:
             # Free prefilters and postfilters params
             if self.schunk.storage.cparams.prefilter != NULL:
                 self.remove_prefilter(func_name=None, _new_ctx=False)
             if self.schunk.storage.dparams.postfilter != NULL:
                 self.remove_postfilter(func_name=None, _new_ctx=False)
 
-            blosc2_schunk_free(self.schunk)
+            # Release the GIL while freeing the C-Blosc2 super-chunk.
+            # blosc2_schunk_free -> blosc2_free_ctx -> release_threadpool
+            # joins worker pthreads; holding the GIL here can cause hangs
+            # when thousands of SChunks are finalized at once (e.g. during
+            # gc.collect() in Python 3.14+ where gen-2 threshold is 0).
+            schunk_ptr = self.schunk
+            self.schunk = NULL
+            with nogil:
+                blosc2_schunk_free(schunk_ptr)
 
 
 # postfilter

src/blosc2/lazyexpr.py

@@ -1182,7 +1182,7 @@ def get_chunk(arr, info, nchunk):
 async def async_read_chunks(arrs, info, queue):
     loop = asyncio.get_event_loop()
     shape, chunks_ = arrs[0].shape, arrs[0].chunks
-    with concurrent.futures.ThreadPoolExecutor() as executor:
+    with concurrent.futures.ThreadPoolExecutor(max_workers=os.cpu_count() or 1) as executor:
         my_chunk_iter = range(arrs[0].schunk.nchunks)
         if len(info) == 5:
             if info[-1] is not None:

tests/conftest.py

@@ -5,6 +5,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 #######################################################################
 
+import gc
 import os
 import sys
 
@@ -14,6 +15,17 @@
 import blosc2
 
 
+# Each SChunk allocates C-level thread pools (pthreads) for its compression
+# and decompression contexts.  Python 3.14 changed the GC gen-2 threshold
+# to 0, so long-lived objects are never collected automatically; they
+# accumulate until an explicit gc.collect() (e.g. pytest session cleanup).
+# Joining thousands of idle pthreads at once can hit the macOS thread-count
+# ceiling (6 144) and hang.  Periodically forcing a full collection keeps
+# the thread count bounded.
+_GC_COLLECT_INTERVAL = 50  # collect every N tests
+_test_counter = 0
+
+
 def expected_nthreads(nthreads: int) -> int:
     return 1 if blosc2.IS_WASM else nthreads
 
@@ -49,3 +61,10 @@ def pytest_runtest_call(item):
         item.runtest()
     except requests.exceptions.RequestException as exc:
         pytest.skip(f"Skipping network test due to request failure: {exc}")
+
+
+def pytest_runtest_teardown(item, nextitem):
+    global _test_counter
+    _test_counter += 1
+    if _test_counter % _GC_COLLECT_INTERVAL == 0:
+        gc.collect()