@@ -74,26 +74,27 @@ static inline PyObject* _PyWeakref_GET_REF(PyObject *ref_obj)
     assert(PyWeakref_Check(ref_obj));
     PyWeakReference *ref = _Py_CAST(PyWeakReference*, ref_obj);
 
-    PyObject *obj = FT_ATOMIC_LOAD_PTR(ref->wr_object);
+#ifdef Py_GIL_DISABLED
+    PyObject *obj = _Py_atomic_load_ptr(&ref->wr_object);
     if (obj == Py_None) {
         // clear_weakref() was called
         return NULL;
     }
-
-    LOCK_WEAKREFS(obj);
-#ifdef Py_GIL_DISABLED
-    if (ref->wr_object == Py_None) {
+    if (_Py_TryIncrefCompare(&ref->wr_object, obj)) {
+        return obj;
+    }
+    return NULL;
+#else
+    PyObject *obj = ref->wr_object;
+    if (obj == Py_None) {
         // clear_weakref() was called
-        UNLOCK_WEAKREFS(obj);
         return NULL;
     }
-#endif
     if (_Py_TryIncref(obj)) {
-        UNLOCK_WEAKREFS(obj);
         return obj;
     }
-    UNLOCK_WEAKREFS(obj);
     return NULL;
+#endif
 }
 
 static inline int _PyWeakref_IS_DEAD(PyObject *ref_obj)
@@ -108,8 +109,8 @@ static inline int _PyWeakref_IS_DEAD(PyObject *ref_obj)
     }
     else {
         LOCK_WEAKREFS(obj);
-        // See _PyWeakref_GET_REF() for the rationale of this test
 #ifdef Py_GIL_DISABLED
+        // The weakref may have been cleared before the lock was acquired.
         ret = (ref->wr_object == Py_None) || _is_dead(obj);
 #else
         ret = _is_dead(obj);

@@ -1026,6 +1026,34 @@ def cb(wparent):
         del root
         gc.collect()
 
+    @unittest.skipIf(is_wasi and Py_DEBUG, "requires deep stack")
+    def test_trashcan_deferred_dealloc(self):
+        # When the C stack is nearly exhausted, the trashcan defers
+        # deallocation of an object whose refcount has dropped to 0, leaving
+        # its weakrefs uncleared.  Calling such a weakref must return None
+        # rather than resurrecting the dead object.
+        class Node(list):
+            pass
+
+        found = []
+        class Trigger:
+            def __init__(self, wr):
+                self.wr = wr
+            def __del__(self):
+                if self.wr() is not None:
+                    found.append(True)
+
+        head = cur = Node()
+        for i in range(200_000):
+            child = Node()
+            # list_dealloc() clears items last to first: the child is
+            # deallocated (or deferred) before the trigger runs.
+            cur.extend([Trigger(weakref.ref(child)), child])
+            cur = child
+        del cur, child
+        del head
+        self.assertEqual(found, [])
+
     def test_callback_attribute(self):
         x = Object(1)
         callback = lambda ref: None

diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2026-10-16-18-25-48.gh-issue-159564.WMRRFA.rst b/Misc/NEWS.d/next/Core_and_Builtins/2026-10-16-18-25-48.gh-issue-159564.WMRRFA.rst
@@ -0,0 +1,3 @@
+Improve the performance and thread scaling of dereferencing weak references
+in the :term:`free-threaded build`.  Dereferencing a weak reference no longer
+takes a lock.
@@ -91,9 +91,9 @@ clear_weakref_lock_held(PyWeakReference *self, PyObject **callback)
             /* If 'self' is the end of the list (and thus self->wr_next ==
                NULL) then the weakref list itself (and thus the value of *list)
                will end up being set to NULL. */
-            FT_ATOMIC_STORE_PTR(*list, self->wr_next);
+            FT_ATOMIC_STORE_PTR_RELEASE(*list, self->wr_next);
         }
-        FT_ATOMIC_STORE_PTR(self->wr_object, Py_None);
+        FT_ATOMIC_STORE_PTR_RELEASE(self->wr_object, Py_None);
         if (self->wr_prev != NULL) {
             self->wr_prev->wr_next = self->wr_next;
         }