From: Brett Cannon <bcannon@gmail.com>
Date: Wed, 21 Jul 2004 02:55:54 +0000 (+0000)
Subject: dummy_threading when run with -O would raise a KeyError in Thread.__delete()
X-Git-Tag: v2.3.5c1~163
X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=9d2ad5f44c7785bc460510f9ca9c4963cf3cfdf5;p=thirdparty%2FPython%2Fcpython.git

dummy_threading when run with -O would raise a KeyError in Thread.__delete()
when called by atexit thanks to dummy_thread always returning -1 for
dummy_thread.get_ident().  Since exception was not an issue, it is now caught
and tossed.

Closes bug #993394.
---

diff --git a/Lib/threading.py b/Lib/threading.py
index df9748124fd6..2784350d166d 100644
--- a/Lib/threading.py
+++ b/Lib/threading.py
@@ -492,8 +492,40 @@ class Thread(_Verbose):
         self.__block.release()
 
     def __delete(self):
+        """Remove the current thread from the dict of currently running
+        threads.
+
+        Must take care to not raise an exception if dummy_thread is being used
+        (and thus this module is being used as an instance of dummy_threading).
+        Since dummy_thread.get_ident() always returns -1 since there is only one
+        thread if dummy_thread is being used.  This means that if any Thread
+        instances are created they will overwrite any other threads registered.
+
+        This is an issue with this method, though, since an instance of
+        _MainThread is always created by 'threading'.  This gets overwritten the
+        instant an instance of Thread is created; both threads will have -1 as
+        their value from dummy_thread.get_ident() and thus have the same key in
+        the dict.  This means that when the _MainThread instance created by
+        'threading' tries to clean itself up when atexit calls this method it
+        gets a key error if another Thread instance was created since that
+        removed the only thing with the key of -1.
+
+        This all means that KeyError from trying to delete something from
+        _active if dummy_threading is being used is a red herring.  But since
+        it isn't if dummy_threading is *not* being used then don't hide the
+        exception.  Also don't need to worry about issues from interpreter
+        shutdown and sys not being defined because the call is protected by a
+        blanket try/except block where that could be a problem.
+
+        """
         _active_limbo_lock.acquire()
-        del _active[_get_ident()]
+        if _sys.modules.has_key('dummy_threading'):
+            try:
+                del _active[_get_ident()]
+            except KeyError:
+                pass
+        else:
+            del _active[_get_ident()]
         _active_limbo_lock.release()
 
     def join(self, timeout=None):
diff --git a/Misc/NEWS b/Misc/NEWS
index 23ddd63e8675..033db637534c 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -43,6 +43,11 @@ Extension modules
 Library
 -------
 
+- Bug #993394.  A KeyError was being raised by Thread.__delete() for
+  dummy_threading when called by atexit if an instance of Thread was created in
+  an interpreter running in -O.  The exception was of no importance and thus is
+  now thrown away if raised.
+
 - Bug #930024: posixpath.realpath() now detects loops from symlinks and returns
   the longest path before the loop begins.