gh-156544: fix free-threading race in UserDict.get() and __getitem__().

When UserDict.__delitem__, pop(), __popitem__(), or clear() are called
concurrently with get() or __getitem__ a race can occur in that get() or
 __getitem__ can see the item as being contained and then they use
self.data[key] to return the item. However, if the item is removed after the
containment check this subscript access will raise KeyError and get() and
__getitem__() will propogate it, resulting in get() not returning default and
__getitem() incorrectly skipping the call it should make to __missing__ (if
defined).

This fix detects this race condition by ignoring the KeyError after
containment checks to allow default to be  returned or __missing__ to be
called.

It is implemented in this unusual way that preserves the containment check
rather than relying solely on KeyError in order to preserve existing semantics
and performance characteristics. Removing the call to __contains__ on
self.data would change how UserData interacts with it and could potentially
break code that relies on  this call.
In addition to preserving the current semantics, get() with a sentinel is not
used to atomically detect if the item is missing. Changing 'in' and '[key]' to
a single call to get() would replace these optimized operators with a more
expensive function  call. Because exceptions incur overhead only when raised,
this implementation preserves existing performance for all cases except when
the race actually occurs, but ensures correct functionality when it does. It
also preserves the interaction semantics with the wrapped dict.

Author: gdchinacat

Lib/collections/__init__.py

@@ -1187,7 +1187,10 @@ def __len__(self):
 
     def __getitem__(self, key):
         if key in self.data:
-            return self.data[key]
+            try:
+                return self.data[key]
+            except KeyError:
+                pass
         if hasattr(self.__class__, "__missing__"):
             return self.__class__.__missing__(self, key)
         raise KeyError(key)
@@ -1208,7 +1211,10 @@ def __contains__(self, key):
 
     def get(self, key, default=None):
         if key in self:
-            return self[key]
+            try:
+                return self[key]
+            except KeyError:
+                pass
         return default