🐛 fix(rw): close sqlite3 cursors and skip SoftFileLock Windows race (#491)

ReadWriteLock._configure_and_begin creates cursors via
Connection.execute() without closing them. On CPython refcounting
destroys them immediately, but on PyPy cursors accumulate until
non-deterministic GC collects them. If Connection.__del__ runs first
and calls sqlite3_close, a later Statement.__del__ calls
sqlite3_finalize on freed memory — segfault. Fix by chaining .close()
on every execute() call.

Skip test_threaded_shared_lock_obj for SoftFileLock on Windows.
SoftFileLock uses file-existence locking where unlink can silently fail
under heavy thread contention when an antivirus scanner or search
indexer momentarily holds the handle after close(). This orphans the
lock file with no recovery path since stale-lock detection is disabled
on Windows and PID-based detection cannot distinguish same-process
threads. This is the same known limitation already documented by the
skip in test_threaded_lock_different_lock_obj.

Author: gaborbernat

src/filelock/_read_write.py

@@ -188,25 +188,25 @@ def _configure_and_begin(
     ) -> None:
         waited = time.perf_counter() - start_time
         timeout_ms = timeout_for_sqlite(timeout, blocking=blocking, already_waited=waited)
-        self._con.execute(f"PRAGMA busy_timeout={timeout_ms};")
+        self._con.execute(f"PRAGMA busy_timeout={timeout_ms};").close()
         # Use legacy journal mode (not WAL) because WAL does not block readers when a concurrent EXCLUSIVE
         # write transaction is active, making read-write locking impossible without modifying table data.
         # MEMORY is safe here since no actual writes happen — crashes cannot corrupt the DB.
         # See https://sqlite.org/lang_transaction.html#deferred_immediate_and_exclusive_transactions
         #
         # Set here (not in __init__) because this pragma itself may block on a locked database,
         # so it must run after busy_timeout is configured above.
-        self._con.execute("PRAGMA journal_mode=MEMORY;")
+        self._con.execute("PRAGMA journal_mode=MEMORY;").close()
         # Recompute remaining timeout after the potentially blocking journal_mode pragma.
         waited = time.perf_counter() - start_time
         if (recomputed := timeout_for_sqlite(timeout, blocking=blocking, already_waited=waited)) != timeout_ms:
-            self._con.execute(f"PRAGMA busy_timeout={recomputed};")
+            self._con.execute(f"PRAGMA busy_timeout={recomputed};").close()
         stmt = "BEGIN EXCLUSIVE TRANSACTION;" if mode == "write" else "BEGIN TRANSACTION;"
-        self._con.execute(stmt)
+        self._con.execute(stmt).close()
         if mode == "read":
             # A SELECT is needed to force SQLite to actually acquire the SHARED lock on the database.
             # https://www.sqlite.org/lockingv3.html#transaction_control
-            self._con.execute("SELECT name FROM sqlite_schema LIMIT 1;")
+            self._con.execute("SELECT name FROM sqlite_schema LIMIT 1;").close()
 
     def _acquire(self, mode: Literal["read", "write"], timeout: float, *, blocking: bool) -> AcquireReturnProxy:
         opposite = "write" if mode == "read" else "read"

tests/test_filelock.py

@@ -242,6 +242,12 @@ def join(self, timeout: float | None = None) -> None:
 
 @pytest.mark.parametrize("lock_type", [FileLock, SoftFileLock])
 def test_threaded_shared_lock_obj(lock_type: type[BaseFileLock], tmp_path: Path) -> None:
+    if sys.platform == "win32" and lock_type.__name__ == "SoftFileLock":
+        pytest.skip(
+            "SoftFileLock uses file-existence locking — on Windows, unlink can silently fail under heavy "
+            "thread contention (EACCES from antivirus/indexer), orphaning the lock file with no recovery path"
+        )
+
     # Runs 100 threads, which need the filelock. The lock must be acquired if at least one thread required it and
     # released, as soon as all threads stopped.
     lock_path = tmp_path / "a"