Add concurrent stress tests for PyBuffer.Dispose and CLR-cycle gc.col…

…lect
pythonnet · filmor · Sep 14, 2026 · May 9, 2026 · May 9, 2026 · May 9, 2026
commit a4597725f3e13c73ff12930a7aef922b6276e9af
diff --git a/src/embed_tests/TestPyBuffer.cs b/src/embed_tests/TestPyBuffer.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Runtime.CompilerServices;
 using System.Text;
+using System.Threading;
 using NUnit.Framework;
 using Python.Runtime;
 using Python.Runtime.Codecs;
@@ -129,6 +130,42 @@ public void MultidimensionalNumPyArray()
             });
         }
 
+        [Test]
+        public void ConcurrentDispose()
+        {
+            // Two threads racing on Dispose() must not double-release the view —
+            // Interlocked.Exchange on disposedValue gates PyBuffer_Release.
+            // Smoke test: no crash, exception, or buffer-protocol violation.
+            using var _ = Py.GIL();
+            using var arr = ByteArrayFromAsciiString("hello world! !$%&/()=?");
+
+            const int iterations = 200;
+            for (int i = 0; i < iterations; i++)
+            {
+                PyBuffer buf = arr.GetBuffer();
+
+                IntPtr ts = PythonEngine.BeginAllowThreads();
+                using var barrier = new Barrier(2);
+                Exception captured = null;
+                Action race = () =>
+                {
+                    try
+                    {
+                        barrier.SignalAndWait();
+                        using (Py.GIL()) buf.Dispose();
+                    }
+                    catch (Exception ex) { Interlocked.CompareExchange(ref captured, ex, null); }
+                };
+                var t1 = new Thread(() => race());
+                var t2 = new Thread(() => race());
+                t1.Start(); t2.Start();
+                t1.Join(); t2.Join();
+                PythonEngine.EndAllowThreads(ts);
+
+                if (captured != null) throw captured;
+            }
+        }
+
         [MethodImpl(MethodImplOptions.NoInlining)]
         static void MakeBufAndLeak(PyObject bufProvider)
         {

diff --git a/tests/test_thread.py b/tests/test_thread.py
@@ -315,3 +315,30 @@ def churn(i):
         return True
 
     assert all(_run_in_threads(churn, n_threads=8))
+
+
+@pytest.mark.skipif(_gil_enabled(), reason="Only meaningful on free-threaded Python (Py_GIL_DISABLED).")
+def test_concurrent_gc_collect_on_clr_cycles():
+    """Concurrent gc.collect on cyclic CLR-derived objects — exercises
+    ClassBase.ClearVisited + ManagedType.TryFreeGCHandle atomic slot.
+
+    Each worker builds short cycles holding a Python subclass of System.Object,
+    then calls gc.collect() while other workers do the same.  Hits the
+    tp_clear/tp_dealloc race path on the per-object GCHandle slot.
+    """
+    import gc
+    import System
+
+    class Cycle(System.Object):
+        __namespace__ = "test_concurrent_gc_collect_on_clr_cycles"
+
+    def churn(_):
+        for _ in range(100):
+            a, b = Cycle(), Cycle()
+            a.peer = b
+            b.peer = a
+            del a, b
+            gc.collect()
+        return True
+
+    assert all(_run_in_threads(churn, n_threads=8))