From 2067bfdf253e134a4144d3747300dbfcc7cc6203 Mon Sep 17 00:00:00 2001 From: Georg Brandl Date: Sun, 25 May 2008 13:05:15 +0000 Subject: [PATCH] Rename thread to _thread and dummy_thread to _dummy_thread. Issue #2875. --- Demo/metaclasses/Synch.py | 2 +- Demo/pysvr/pysvr.py | 8 +++--- Demo/threads/Coroutine.py | 2 +- Demo/threads/Generator.py | 2 +- Demo/threads/find.py | 2 +- Demo/threads/sync.py | 2 +- Demo/threads/telnet.py | 2 +- Doc/c-api/exceptions.rst | 2 +- Doc/c-api/init.rst | 4 +-- Doc/c-api/typeobj.rst | 2 +- Doc/library/_dummy_thread.rst | 22 +++++++++++++++ Doc/library/{thread.rst => _thread.rst} | 17 ++++++----- Doc/library/dummy_thread.rst | 23 --------------- Doc/library/dummy_threading.rst | 13 ++++----- Doc/library/someos.rst | 4 +-- Doc/library/threading.rst | 9 +++--- Include/ceval.h | 2 +- Lib/{dummy_thread.py => _dummy_thread.py} | 24 ++++++++-------- Lib/_strptime.py | 4 +-- Lib/bsddb/__init__.py | 4 +-- Lib/dummy_threading.py | 20 ++++++------- Lib/idlelib/run.py | 2 +- Lib/logging/__init__.py | 2 +- Lib/logging/config.py | 2 +- Lib/mimetools.py | 8 +++--- Lib/pydoc.py | 2 +- Lib/telnetlib.py | 4 +-- Lib/tempfile.py | 4 +-- Lib/test/crashers/multithreaded_close.py | 4 +-- Lib/test/fork_wait.py | 4 +-- Lib/test/test___all__.py | 2 +- Lib/test/test_asynchat.py | 2 +- Lib/test/test_capi.py | 8 +++--- Lib/test/test_dummy_thread.py | 6 ++-- Lib/test/test_socket.py | 3 +- Lib/test/test_sys.py | 8 +++--- Lib/test/test_thread.py | 2 +- Lib/test/test_threaded_import.py | 2 +- Lib/test/test_threadedtempfile.py | 2 +- Lib/test/test_threading.py | 18 ++++++------ Lib/test/test_threadsignals.py | 2 +- Lib/threading.py | 31 +++++++++------------ Misc/cheatsheet | 4 +-- Modules/Setup.config.in | 2 +- Modules/{threadmodule.c => _threadmodule.c} | 6 ++-- PC/VC6/pythoncore.dsp | 2 +- PC/VS7.1/pythoncore.vcproj | 2 +- PC/VS8.0/pythoncore.vcproj | 2 +- PC/config.c | 4 +-- PC/os2emx/Makefile | 2 +- PC/os2emx/config.c | 4 +-- PC/os2emx/python26.def | 4 +-- PC/os2vacpp/config.c | 4 +-- PC/os2vacpp/makefile | 2 +- PC/os2vacpp/makefile.omk | 2 +- PCbuild/pythoncore.vcproj | 2 +- 56 files changed, 161 insertions(+), 169 deletions(-) create mode 100644 Doc/library/_dummy_thread.rst rename Doc/library/{thread.rst => _thread.rst} (94%) delete mode 100644 Doc/library/dummy_thread.rst rename Lib/{dummy_thread.py => _dummy_thread.py} (85%) rename Modules/{threadmodule.c => _threadmodule.c} (99%) diff --git a/Demo/metaclasses/Synch.py b/Demo/metaclasses/Synch.py index 445ce834802..e02f88f6228 100644 --- a/Demo/metaclasses/Synch.py +++ b/Demo/metaclasses/Synch.py @@ -4,7 +4,7 @@ This metaclass makes it possible to declare synchronized methods. """ -import thread +import _thread as thread # First we need to define a reentrant lock. # This is generally useful and should probably be in a standard Python diff --git a/Demo/pysvr/pysvr.py b/Demo/pysvr/pysvr.py index b200fade480..3e94dbe05c0 100755 --- a/Demo/pysvr/pysvr.py +++ b/Demo/pysvr/pysvr.py @@ -12,7 +12,7 @@ can log in on your machine. Use with caution! """ -import sys, os, string, getopt, thread, socket, traceback +import sys, os, string, getopt, _thread, socket, traceback PORT = 4000 # Default port @@ -52,17 +52,17 @@ def main_thread(port): conn.close() print("Refusing connection from non-local host", addr[0], ".") continue - thread.start_new_thread(service_thread, (conn, addr)) + _thread.start_new_thread(service_thread, (conn, addr)) del conn, addr def service_thread(conn, addr): (caddr, cport) = addr - print("Thread %s has connection from %s.\n" % (str(thread.get_ident()), + print("Thread %s has connection from %s.\n" % (str(_thread.get_ident()), caddr), end=' ') stdin = conn.makefile("r") stdout = conn.makefile("w", 0) run_interpreter(stdin, stdout) - print("Thread %s is done.\n" % str(thread.get_ident()), end=' ') + print("Thread %s is done.\n" % str(_thread.get_ident()), end=' ') def run_interpreter(stdin, stdout): globals = {} diff --git a/Demo/threads/Coroutine.py b/Demo/threads/Coroutine.py index 4a155f89ae9..e7d882dfc5c 100644 --- a/Demo/threads/Coroutine.py +++ b/Demo/threads/Coroutine.py @@ -66,7 +66,7 @@ # current implementation consumes a thread for each coroutine that # may be resumed. -import thread +import _thread as thread import sync class _CoEvent: diff --git a/Demo/threads/Generator.py b/Demo/threads/Generator.py index 0cc1bda3480..38c0c8adb87 100644 --- a/Demo/threads/Generator.py +++ b/Demo/threads/Generator.py @@ -1,6 +1,6 @@ # Generator implementation using threads -import thread +import _thread as thread Killed = 'Generator.Killed' diff --git a/Demo/threads/find.py b/Demo/threads/find.py index 57fe81e3808..2b4ef7dec04 100644 --- a/Demo/threads/find.py +++ b/Demo/threads/find.py @@ -20,7 +20,7 @@ import getopt import time import os from stat import * -import thread +import _thread as thread # Work queue class. Usage: diff --git a/Demo/threads/sync.py b/Demo/threads/sync.py index 61e16287e47..90fff2e49da 100644 --- a/Demo/threads/sync.py +++ b/Demo/threads/sync.py @@ -268,7 +268,7 @@ # if there are are no threads waiting to write. (This is a # weakness of the interface!) -import thread +import _thread as thread class condition: def __init__(self, lock=None): diff --git a/Demo/threads/telnet.py b/Demo/threads/telnet.py index 73663412326..dfe49055695 100644 --- a/Demo/threads/telnet.py +++ b/Demo/threads/telnet.py @@ -15,7 +15,7 @@ import sys, os, time from socket import * -import thread +import _thread as thread BUFSIZE = 8*1024 diff --git a/Doc/c-api/exceptions.rst b/Doc/c-api/exceptions.rst index 9c9ee7ff7a0..7440dda1506 100644 --- a/Doc/c-api/exceptions.rst +++ b/Doc/c-api/exceptions.rst @@ -351,7 +351,7 @@ in various ways. There is a separate error indicator for each thread. be raised. It may be called without holding the interpreter lock. .. % XXX This was described as obsolete, but is used in - .. % thread.interrupt_main() (used from IDLE), so it's still needed. + .. % _thread.interrupt_main() (used from IDLE), so it's still needed. .. cfunction:: int PySignal_SetWakeupFd(int fd) diff --git a/Doc/c-api/init.rst b/Doc/c-api/init.rst index 4bf644588a4..864991e96ab 100644 --- a/Doc/c-api/init.rst +++ b/Doc/c-api/init.rst @@ -539,7 +539,7 @@ supports the creation of additional interpreters (using This is a no-op when called for a second time. It is safe to call this function before calling :cfunc:`Py_Initialize`. - .. index:: module: thread + .. index:: module: _thread When only the main thread exists, no lock operations are needed. This is a common situation (most Python programs do not use threads), and the lock @@ -547,7 +547,7 @@ supports the creation of additional interpreters (using initially. This situation is equivalent to having acquired the lock: when there is only a single thread, all object accesses are safe. Therefore, when this function initializes the lock, it also acquires it. Before the Python - :mod:`thread` module creates a new thread, knowing that either it has the lock + :mod:`_thread` module creates a new thread, knowing that either it has the lock or the lock hasn't been created yet, it calls :cfunc:`PyEval_InitThreads`. When this call returns, it is guaranteed that the lock has been created and that the calling thread has acquired it. diff --git a/Doc/c-api/typeobj.rst b/Doc/c-api/typeobj.rst index 9f475167733..8ea61b024d5 100644 --- a/Doc/c-api/typeobj.rst +++ b/Doc/c-api/typeobj.rst @@ -488,7 +488,7 @@ type objects) *must* have the :attr:`ob_size` field. reference cycles. A typical implementation of a :attr:`tp_traverse` function simply calls :cfunc:`Py_VISIT` on each of the instance's members that are Python objects. For example, this is function :cfunc:`local_traverse` from the - :mod:`thread` extension module:: + :mod:`_thread` extension module:: static int local_traverse(localobject *self, visitproc visit, void *arg) diff --git a/Doc/library/_dummy_thread.rst b/Doc/library/_dummy_thread.rst new file mode 100644 index 00000000000..62e57080a78 --- /dev/null +++ b/Doc/library/_dummy_thread.rst @@ -0,0 +1,22 @@ +:mod:`_dummy_thread` --- Drop-in replacement for the :mod:`_thread` module +========================================================================== + +.. module:: _dummy_thread + :synopsis: Drop-in replacement for the _thread module. + + +This module provides a duplicate interface to the :mod:`_thread` module. It is +meant to be imported when the :mod:`_thread` module is not provided on a +platform. + +Suggested usage is:: + + try: + import _thread + except ImportError: + import dummy_thread as _thread + +Be careful to not use this module where deadlock might occur from a thread being +created that blocks waiting for another thread to be created. This often occurs +with blocking I/O. + diff --git a/Doc/library/thread.rst b/Doc/library/_thread.rst similarity index 94% rename from Doc/library/thread.rst rename to Doc/library/_thread.rst index 31d58e784a3..95214d6515d 100644 --- a/Doc/library/thread.rst +++ b/Doc/library/_thread.rst @@ -1,9 +1,8 @@ +:mod:`_thread` --- Low-level threading API +========================================== -:mod:`thread` --- Multiple threads of control -============================================= - -.. module:: thread - :synopsis: Create multiple threads of control within one interpreter. +.. module:: _thread + :synopsis: Low-level threading API. .. index:: @@ -25,8 +24,8 @@ threading API built on top of this module. The module is optional. It is supported on Windows, Linux, SGI IRIX, Solaris 2.x, as well as on systems that have a POSIX thread (a.k.a. "pthread") -implementation. For systems lacking the :mod:`thread` module, the -:mod:`dummy_thread` module is available. It duplicates this module's interface +implementation. For systems lacking the :mod:`_thread` module, the +:mod:`_dummy_thread` module is available. It duplicates this module's interface and can be used as a drop-in replacement. It defines the following constant and functions: @@ -132,9 +131,9 @@ Lock objects have the following methods: In addition to these methods, lock objects can also be used via the :keyword:`with` statement, e.g.:: - import thread + import _thread - a_lock = thread.allocate_lock() + a_lock = _thread.allocate_lock() with a_lock: print("a_lock is locked while this executes") diff --git a/Doc/library/dummy_thread.rst b/Doc/library/dummy_thread.rst deleted file mode 100644 index 0b2cb179a60..00000000000 --- a/Doc/library/dummy_thread.rst +++ /dev/null @@ -1,23 +0,0 @@ - -:mod:`dummy_thread` --- Drop-in replacement for the :mod:`thread` module -======================================================================== - -.. module:: dummy_thread - :synopsis: Drop-in replacement for the thread module. - - -This module provides a duplicate interface to the :mod:`thread` module. It is -meant to be imported when the :mod:`thread` module is not provided on a -platform. - -Suggested usage is:: - - try: - import thread as _thread - except ImportError: - import dummy_thread as _thread - -Be careful to not use this module where deadlock might occur from a thread -being created that blocks waiting for another thread to be created. This often -occurs with blocking I/O. - diff --git a/Doc/library/dummy_threading.rst b/Doc/library/dummy_threading.rst index 0ffb68732fd..0658df2d27f 100644 --- a/Doc/library/dummy_threading.rst +++ b/Doc/library/dummy_threading.rst @@ -1,4 +1,3 @@ - :mod:`dummy_threading` --- Drop-in replacement for the :mod:`threading` module ============================================================================== @@ -7,17 +6,17 @@ This module provides a duplicate interface to the :mod:`threading` module. It -is meant to be imported when the :mod:`thread` module is not provided on a +is meant to be imported when the :mod:`_thread` module is not provided on a platform. Suggested usage is:: try: - import threading as _threading + import threading except ImportError: - import dummy_threading as _threading + import dummy_threading -Be careful to not use this module where deadlock might occur from a thread -being created that blocks waiting for another thread to be created. This often -occurs with blocking I/O. +Be careful to not use this module where deadlock might occur from a thread being +created that blocks waiting for another thread to be created. This often occurs +with blocking I/O. diff --git a/Doc/library/someos.rst b/Doc/library/someos.rst index 5ee96bc35b8..160ce48fb26 100644 --- a/Doc/library/someos.rst +++ b/Doc/library/someos.rst @@ -14,10 +14,10 @@ some other systems as well (e.g. Windows or NT). Here's an overview: .. toctree:: select.rst - thread.rst threading.rst - dummy_thread.rst dummy_threading.rst + _thread.rst + _dummy_thread.rst mmap.rst readline.rst rlcompleter.rst diff --git a/Doc/library/threading.rst b/Doc/library/threading.rst index 6be2f62cbee..2381f24838d 100644 --- a/Doc/library/threading.rst +++ b/Doc/library/threading.rst @@ -6,12 +6,11 @@ :synopsis: Higher-level threading interface. -This module constructs higher-level threading interfaces on top of the lower -level :mod:`thread` module. -See also the :mod:`queue` module. +This module constructs higher-level threading interfaces on top of the lower +level :mod:`_thread` module. See also the :mod:`queue` module. The :mod:`dummy_threading` module is provided for situations where -:mod:`threading` cannot be used because :mod:`thread` is missing. +:mod:`threading` cannot be used because :mod:`_thread` is missing. This module defines the following functions and objects: @@ -170,7 +169,7 @@ Lock Objects A primitive lock is a synchronization primitive that is not owned by a particular thread when locked. In Python, it is currently the lowest level -synchronization primitive available, implemented directly by the :mod:`thread` +synchronization primitive available, implemented directly by the :mod:`_thread` extension module. A primitive lock is in one of two states, "locked" or "unlocked". It is created diff --git a/Include/ceval.h b/Include/ceval.h index 03eb8cb9545..f0385cf83b4 100644 --- a/Include/ceval.h +++ b/Include/ceval.h @@ -120,7 +120,7 @@ PyAPI_DATA(int) _Py_CheckInterval; Py_END_ALLOW_THREADS!!! The function PyEval_InitThreads() should be called only from - initthread() in "threadmodule.c". + init_thread() in "_threadmodule.c". Note that not yet all candidates have been converted to use this mechanism! diff --git a/Lib/dummy_thread.py b/Lib/_dummy_thread.py similarity index 85% rename from Lib/dummy_thread.py rename to Lib/_dummy_thread.py index c1313846e48..352215ae67d 100644 --- a/Lib/dummy_thread.py +++ b/Lib/_dummy_thread.py @@ -6,9 +6,9 @@ not need to be rewritten for when the thread module is not present. Suggested usage is:: try: - import thread + import _thread except ImportError: - import dummy_thread as thread + import _dummy_thread as _thread """ # Exports only things specified by thread documentation; @@ -20,17 +20,17 @@ import traceback as _traceback import warnings class error(Exception): - """Dummy implementation of thread.error.""" + """Dummy implementation of _thread.error.""" def __init__(self, *args): self.args = args def start_new_thread(function, args, kwargs={}): - """Dummy implementation of thread.start_new_thread(). + """Dummy implementation of _thread.start_new_thread(). Compatibility is maintained by making sure that ``args`` is a tuple and ``kwargs`` is a dictionary. If an exception is raised - and it is SystemExit (which can be done by thread.exit()) it is + and it is SystemExit (which can be done by _thread.exit()) it is caught and nothing is done; all other exceptions are printed out by using traceback.print_exc(). @@ -57,34 +57,34 @@ def start_new_thread(function, args, kwargs={}): raise KeyboardInterrupt def exit(): - """Dummy implementation of thread.exit().""" + """Dummy implementation of _thread.exit().""" raise SystemExit def get_ident(): - """Dummy implementation of thread.get_ident(). + """Dummy implementation of _thread.get_ident(). - Since this module should only be used when threadmodule is not + Since this module should only be used when _threadmodule is not available, it is safe to assume that the current process is the only thread. Thus a constant can be safely returned. """ return -1 def allocate_lock(): - """Dummy implementation of thread.allocate_lock().""" + """Dummy implementation of _thread.allocate_lock().""" return LockType() def stack_size(size=None): - """Dummy implementation of thread.stack_size().""" + """Dummy implementation of _thread.stack_size().""" if size is not None: raise error("setting thread stack size not supported") return 0 class LockType(object): - """Class implementing dummy implementation of thread.LockType. + """Class implementing dummy implementation of _thread.LockType. Compatibility is maintained by maintaining self.locked_status which is a boolean that stores the state of the lock. Pickling of - the lock, though, should not be done since if the thread module is + the lock, though, should not be done since if the _thread module is then used with an unpickled ``lock()`` from here problems could occur from this class not having atomic methods. diff --git a/Lib/_strptime.py b/Lib/_strptime.py index b323e8fc4ca..c3568b0d1d4 100644 --- a/Lib/_strptime.py +++ b/Lib/_strptime.py @@ -18,9 +18,9 @@ from re import IGNORECASE from re import escape as re_escape from datetime import date as datetime_date try: - from thread import allocate_lock as _thread_allocate_lock + from _thread import allocate_lock as _thread_allocate_lock except: - from dummy_thread import allocate_lock as _thread_allocate_lock + from _dummy_thread import allocate_lock as _thread_allocate_lock __all__ = [] diff --git a/Lib/bsddb/__init__.py b/Lib/bsddb/__init__.py index b2786d32e20..0e682197f15 100644 --- a/Lib/bsddb/__init__.py +++ b/Lib/bsddb/__init__.py @@ -526,8 +526,8 @@ def _checkflag(flag, file): # BerkeleyDB was too. try: - import thread - del thread + import _thread + del _thread if db.version() < (3, 3, 0): db.DB_THREAD = 0 except ImportError: diff --git a/Lib/dummy_threading.py b/Lib/dummy_threading.py index 81028a3d4e8..1bb7eee338a 100644 --- a/Lib/dummy_threading.py +++ b/Lib/dummy_threading.py @@ -3,12 +3,12 @@ The module ``_dummy_threading`` is added to ``sys.modules`` in order to not have ``threading`` considered imported. Had ``threading`` been directly imported it would have made all subsequent imports succeed -regardless of whether ``thread`` was available which is not desired. +regardless of whether ``_thread`` was available which is not desired. """ from sys import modules as sys_modules -import dummy_thread +import _dummy_thread # Declaring now so as to not have to nest ``try``s to get proper clean-up. holding_thread = False @@ -16,15 +16,15 @@ holding_threading = False holding__threading_local = False try: - # Could have checked if ``thread`` was not in sys.modules and gone + # Could have checked if ``_thread`` was not in sys.modules and gone # a different route, but decided to mirror technique used with # ``threading`` below. - if 'thread' in sys_modules: - held_thread = sys_modules['thread'] + if '_thread' in sys_modules: + held_thread = sys_modules['_thread'] holding_thread = True - # Must have some module named ``thread`` that implements its API + # Must have some module named ``_thread`` that implements its API # in order to initially import ``threading``. - sys_modules['thread'] = sys_modules['dummy_thread'] + sys_modules['_thread'] = sys_modules['_dummy_thread'] if 'threading' in sys_modules: # If ``threading`` is already imported, might as well prevent @@ -68,11 +68,11 @@ finally: # Put back ``thread`` if we overwrote, else del the entry we made if holding_thread: - sys_modules['thread'] = held_thread + sys_modules['_thread'] = held_thread del held_thread else: - del sys_modules['thread'] + del sys_modules['_thread'] del holding_thread - del dummy_thread + del _dummy_thread del sys_modules diff --git a/Lib/idlelib/run.py b/Lib/idlelib/run.py index c9f50102119..7a662c97d54 100644 --- a/Lib/idlelib/run.py +++ b/Lib/idlelib/run.py @@ -3,7 +3,7 @@ import linecache import time import socket import traceback -import thread +import _thread as thread import threading import queue diff --git a/Lib/logging/__init__.py b/Lib/logging/__init__.py index 92ab502eae2..99e813bd7da 100644 --- a/Lib/logging/__init__.py +++ b/Lib/logging/__init__.py @@ -35,7 +35,7 @@ except ImportError: codecs = None try: - import thread + import _thread as thread import threading except ImportError: thread = None diff --git a/Lib/logging/config.py b/Lib/logging/config.py index 006d6690e5a..73f3eccc6e2 100644 --- a/Lib/logging/config.py +++ b/Lib/logging/config.py @@ -27,7 +27,7 @@ To use, simply 'import logging' and log away! import sys, logging, logging.handlers, socket, struct, os, traceback try: - import thread + import _thread as thread import threading except ImportError: thread = None diff --git a/Lib/mimetools.py b/Lib/mimetools.py index 0112f481f0c..3ea5e1b3e60 100644 --- a/Lib/mimetools.py +++ b/Lib/mimetools.py @@ -96,11 +96,11 @@ class Message(rfc822.Message): # ----------------- try: - import thread + import _thread except ImportError: - import dummy_thread as thread -_counter_lock = thread.allocate_lock() -del thread + import _dummy_thread as _thread +_counter_lock = _thread.allocate_lock() +del _thread _counter = 0 def _get_next_counter(): diff --git a/Lib/pydoc.py b/Lib/pydoc.py index 57bd5e2298c..140e1d89270 100755 --- a/Lib/pydoc.py +++ b/Lib/pydoc.py @@ -347,7 +347,7 @@ class Doc: if (isinstance(object, type(os)) and (object.__name__ in ('errno', 'exceptions', 'gc', 'imp', 'marshal', 'posix', 'signal', 'sys', - 'thread', 'zipimport') or + '_thread', 'zipimport') or (file.startswith(basedir) and not file.startswith(os.path.join(basedir, 'site-packages'))))): if docloc.startswith("http://"): diff --git a/Lib/telnetlib.py b/Lib/telnetlib.py index db372000d3a..33029e10471 100644 --- a/Lib/telnetlib.py +++ b/Lib/telnetlib.py @@ -548,8 +548,8 @@ class Telnet: def mt_interact(self): """Multithreaded version of interact().""" - import thread - thread.start_new_thread(self.listener, ()) + import _thread + _thread.start_new_thread(self.listener, ()) while 1: line = sys.stdin.readline() if not line: diff --git a/Lib/tempfile.py b/Lib/tempfile.py index 1041c143379..2caa56ad45f 100644 --- a/Lib/tempfile.py +++ b/Lib/tempfile.py @@ -52,9 +52,9 @@ else: try: - import thread as _thread + import _thread except ImportError: - import dummy_thread as _thread + import _dummy_thread as _thread _allocate_lock = _thread.allocate_lock _text_openflags = _os.O_RDWR | _os.O_CREAT | _os.O_EXCL diff --git a/Lib/test/crashers/multithreaded_close.py b/Lib/test/crashers/multithreaded_close.py index 52243414d6d..f862d28b19c 100644 --- a/Lib/test/crashers/multithreaded_close.py +++ b/Lib/test/crashers/multithreaded_close.py @@ -6,9 +6,9 @@ # http://bugs.python.org/issue595601 # http://bugs.python.org/issue815646 -import thread +import _thread while 1: f = open("multithreaded_close.tmp", "w") - thread.start_new_thread(f.close, ()) + _thread.start_new_thread(f.close, ()) f.close() diff --git a/Lib/test/fork_wait.py b/Lib/test/fork_wait.py index 678e3c4ded9..03a4d6f984e 100644 --- a/Lib/test/fork_wait.py +++ b/Lib/test/fork_wait.py @@ -9,7 +9,7 @@ On some systems (e.g. Solaris without posix threads) we find that all active threads survive in the child after a fork(); this is an error. """ -import os, sys, time, thread, unittest +import os, sys, time, _thread, unittest LONGSLEEP = 2 SHORTSLEEP = 0.5 @@ -43,7 +43,7 @@ class ForkWait(unittest.TestCase): def test_wait(self): for i in range(NUM_THREADS): - thread.start_new(self.f, (i,)) + _thread.start_new(self.f, (i,)) time.sleep(LONGSLEEP) diff --git a/Lib/test/test___all__.py b/Lib/test/test___all__.py index c58aeadacef..615f6c5a1e2 100644 --- a/Lib/test/test___all__.py +++ b/Lib/test/test___all__.py @@ -63,7 +63,7 @@ class AllTest(unittest.TestCase): self.check_all("dircache") self.check_all("dis") self.check_all("doctest") - self.check_all("dummy_thread") + self.check_all("_dummy_thread") self.check_all("dummy_threading") self.check_all("filecmp") self.check_all("fileinput") diff --git a/Lib/test/test_asynchat.py b/Lib/test/test_asynchat.py index 4d49f581de6..082fde98239 100644 --- a/Lib/test/test_asynchat.py +++ b/Lib/test/test_asynchat.py @@ -1,6 +1,6 @@ # test asynchat -- requires threading -import thread # If this fails, we can't test this module +import _thread as thread # If this fails, we can't test this module import asyncore, asynchat, socket, threading, time import unittest import sys diff --git a/Lib/test/test_capi.py b/Lib/test/test_capi.py index df5ce0b6584..6c87645b063 100644 --- a/Lib/test/test_capi.py +++ b/Lib/test/test_capi.py @@ -22,13 +22,13 @@ def test_main(): idents = [] def callback(): - idents.append(thread.get_ident()) + idents.append(_thread.get_ident()) _testcapi._test_thread_state(callback) a = b = callback time.sleep(1) # Check our main thread is in the list exactly 3 times. - if idents.count(thread.get_ident()) != 3: + if idents.count(_thread.get_ident()) != 3: raise support.TestFailed( "Couldn't find main thread correctly in the list") @@ -39,11 +39,11 @@ def test_main(): have_thread_state = False if have_thread_state: - import thread + import _thread import time TestThreadState() import threading - t=threading.Thread(target=TestThreadState) + t = threading.Thread(target=TestThreadState) t.start() t.join() diff --git a/Lib/test/test_dummy_thread.py b/Lib/test/test_dummy_thread.py index 585711f22b3..5b7db188b7f 100644 --- a/Lib/test/test_dummy_thread.py +++ b/Lib/test/test_dummy_thread.py @@ -5,15 +5,15 @@ to be used, test_main() can be called with the module to use as the thread implementation as its sole argument. """ -import dummy_thread as _thread +import _dummy_thread as _thread import time import queue import random import unittest from test import support -DELAY = 0 # Set > 0 when testing a module other than dummy_thread, such as - # the 'thread' module. +DELAY = 0 # Set > 0 when testing a module other than _dummy_thread, such as + # the '_thread' module. class LockTests(unittest.TestCase): """Test lock objects.""" diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py index 349548f7173..d12968c0d1d 100644 --- a/Lib/test/test_socket.py +++ b/Lib/test/test_socket.py @@ -6,7 +6,8 @@ from test import support import errno import socket import select -import thread, threading +import _thread as thread +import threading import time import traceback import queue diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py index 7c66e0d768a..231b4603829 100644 --- a/Lib/test/test_sys.py +++ b/Lib/test/test_sys.py @@ -191,7 +191,7 @@ class SysModuleTest(unittest.TestCase): def test_current_frames(self): have_threads = True try: - import thread + import _thread except ImportError: have_threads = False @@ -202,7 +202,7 @@ class SysModuleTest(unittest.TestCase): # Test sys._current_frames() in a WITH_THREADS build. def current_frames_with_threads(self): - import threading, thread + import threading, _thread import traceback # Spawn a thread that blocks at a known place. Then the main @@ -216,7 +216,7 @@ class SysModuleTest(unittest.TestCase): g456() def g456(): - thread_info.append(thread.get_ident()) + thread_info.append(_thread.get_ident()) entered_g.set() leave_g.wait() @@ -232,7 +232,7 @@ class SysModuleTest(unittest.TestCase): d = sys._current_frames() - main_id = thread.get_ident() + main_id = _thread.get_ident() self.assert_(main_id in d) self.assert_(thread_id in d) diff --git a/Lib/test/test_thread.py b/Lib/test/test_thread.py index cff9f81ff5e..84d5a9d8eb6 100644 --- a/Lib/test/test_thread.py +++ b/Lib/test/test_thread.py @@ -2,7 +2,7 @@ import os import unittest import random from test import support -import thread +import _thread as thread import time diff --git a/Lib/test/test_threaded_import.py b/Lib/test/test_threaded_import.py index fbe479cd308..67d1505b965 100644 --- a/Lib/test/test_threaded_import.py +++ b/Lib/test/test_threaded_import.py @@ -5,7 +5,7 @@ # complains several times about module random having no attribute # randrange, and then Python hangs. -import thread +import _thread as thread from test.support import verbose, TestSkipped, TestFailed critical_section = thread.allocate_lock() diff --git a/Lib/test/test_threadedtempfile.py b/Lib/test/test_threadedtempfile.py index fb122d0d87d..d93b3824faf 100644 --- a/Lib/test/test_threadedtempfile.py +++ b/Lib/test/test_threadedtempfile.py @@ -16,7 +16,7 @@ provoking a 2.0 failure under Linux. NUM_THREADS = 20 FILES_PER_THREAD = 50 -import thread # If this fails, we can't test this module +import _thread as thread # If this fails, we can't test this module import threading import tempfile diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py index 9582dde1e4c..3c09b0bd272 100644 --- a/Lib/test/test_threading.py +++ b/Lib/test/test_threading.py @@ -5,7 +5,7 @@ from test.support import verbose import random import sys import threading -import thread +import _thread import time import unittest import weakref @@ -88,7 +88,7 @@ class ThreadTests(unittest.TestCase): print('with 256kB thread stack size...') try: threading.stack_size(262144) - except thread.error: + except _thread.error: if verbose: print('platform does not support changing thread stack size') return @@ -101,7 +101,7 @@ class ThreadTests(unittest.TestCase): print('with 1MB thread stack size...') try: threading.stack_size(0x100000) - except thread.error: + except _thread.error: if verbose: print('platform does not support changing thread stack size') return @@ -120,7 +120,7 @@ class ThreadTests(unittest.TestCase): mutex = threading.Lock() mutex.acquire() - tid = thread.start_new_thread(f, (mutex,)) + tid = _thread.start_new_thread(f, (mutex,)) # Wait for the thread to finish. mutex.acquire() self.assert_(tid in threading._active) @@ -154,7 +154,7 @@ class ThreadTests(unittest.TestCase): class Worker(threading.Thread): def run(self): - self.id = thread.get_ident() + self.id = _thread.get_ident() self.finished = False try: @@ -211,10 +211,10 @@ class ThreadTests(unittest.TestCase): import subprocess rc = subprocess.call([sys.executable, "-c", """if 1: - import ctypes, sys, time, thread + import ctypes, sys, time, _thread # This lock is used as a simple event variable. - ready = thread.allocate_lock() + ready = _thread.allocate_lock() ready.acquire() # Module globals are cleared before __del__ is run @@ -231,7 +231,7 @@ class ThreadTests(unittest.TestCase): ready.release() time.sleep(100) - thread.start_new_thread(waitingThread, ()) + _thread.start_new_thread(waitingThread, ()) ready.acquire() # Be sure the other thread is waiting. sys.exit(42) """]) @@ -357,7 +357,7 @@ class ThreadingExceptionTests(unittest.TestCase): def test_main(): test.support.run_unittest(ThreadTests, - ThreadingExceptionTests) + ThreadingExceptionTests) if __name__ == "__main__": test_main() diff --git a/Lib/test/test_threadsignals.py b/Lib/test/test_threadsignals.py index cbed42c002e..14bd3b7f409 100644 --- a/Lib/test/test_threadsignals.py +++ b/Lib/test/test_threadsignals.py @@ -1,7 +1,7 @@ """PyUnit testing that threads honor our signal semantics""" import unittest -import thread +import _thread as thread import signal import os import sys diff --git a/Lib/threading.py b/Lib/threading.py index be97807118b..673d88e8ef0 100644 --- a/Lib/threading.py +++ b/Lib/threading.py @@ -1,12 +1,7 @@ """Thread module emulating a subset of Java's threading model.""" import sys as _sys - -try: - import thread -except ImportError: - del _sys.modules[__name__] - raise +import _thread from time import time as _time, sleep as _sleep from traceback import format_exc as _format_exc @@ -17,11 +12,11 @@ __all__ = ['activeCount', 'Condition', 'currentThread', 'enumerate', 'Event', 'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Thread', 'Timer', 'setprofile', 'settrace', 'local', 'stack_size'] -_start_new_thread = thread.start_new_thread -_allocate_lock = thread.allocate_lock -_get_ident = thread.get_ident -ThreadError = thread.error -del thread +_start_new_thread = _thread.start_new_thread +_allocate_lock = _thread.allocate_lock +_get_ident = _thread.get_ident +ThreadError = _thread.error +del _thread # Debug support (adapted from ihooks.py). @@ -556,18 +551,18 @@ class Thread(_Verbose): def _delete(self): "Remove current thread from the dict of currently running threads." - # Notes about running with dummy_thread: + # Notes about running with _dummy_thread: # - # Must take care to not raise an exception if dummy_thread is being + # 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). dummy_thread.get_ident() always returns -1 since - # there is only one thread if dummy_thread is being used. Thus + # dummy_threading). _dummy_thread.get_ident() always returns -1 since + # there is only one thread if _dummy_thread is being used. Thus # len(_active) is always <= 1 here, and any Thread instance created # overwrites the (if any) thread currently registered in _active. # # An instance of _MainThread is always created by 'threading'. This # gets overwritten the instant an instance of Thread is created; both - # threads return -1 from dummy_thread.get_ident() and thus have the + # threads return -1 from _dummy_thread.get_ident() and thus have the # same key in the dict. So when the _MainThread instance created by # 'threading' tries to clean itself up when atexit calls this method # it gets a KeyError if another Thread instance was created. @@ -763,7 +758,7 @@ def enumerate(): _active_limbo_lock.release() return active -from thread import stack_size +from _thread import stack_size # Create the main thread object, # and make it available for the interpreter @@ -775,7 +770,7 @@ _shutdown = _MainThread()._exitfunc # module, or from the python fallback try: - from thread import _local as local + from _thread import _local as local except ImportError: from _threading_local import local diff --git a/Misc/cheatsheet b/Misc/cheatsheet index d81897ff7bc..c383e4a1db6 100644 --- a/Misc/cheatsheet +++ b/Misc/cheatsheet @@ -1988,8 +1988,8 @@ zipfile Read & write PK zipped files. re Functions useful for working with regular expressions string Useful string and characters functions and exceptions random Mersenne Twister pseudo-random number generator - thread Low-level primitives for working with process threads - threading idem, new recommanded interface. + _thread Low-level primitives for working with process threads + threading idem, new recommended interface. * Unix/Posix * diff --git a/Modules/Setup.config.in b/Modules/Setup.config.in index fed62e9d8ef..5ac2404bf8a 100644 --- a/Modules/Setup.config.in +++ b/Modules/Setup.config.in @@ -4,7 +4,7 @@ # based on configure-time options. # Threading -@USE_THREAD_MODULE@thread threadmodule.c +@USE_THREAD_MODULE@_thread _threadmodule.c # The signal module @USE_SIGNAL_MODULE@signal signalmodule.c diff --git a/Modules/threadmodule.c b/Modules/_threadmodule.c similarity index 99% rename from Modules/threadmodule.c rename to Modules/_threadmodule.c index b8b7fb567a0..971ff56adf3 100644 --- a/Modules/threadmodule.c +++ b/Modules/_threadmodule.c @@ -688,7 +688,7 @@ unlock it. A thread attempting to lock a lock that it has already locked\n\ will block until another thread unlocks it. Deadlocks may ensue."); PyMODINIT_FUNC -initthread(void) +init_thread(void) { PyObject *m, *d; @@ -699,13 +699,13 @@ initthread(void) return; /* Create the module and add the functions */ - m = Py_InitModule3("thread", thread_methods, thread_doc); + m = Py_InitModule3("_thread", thread_methods, thread_doc); if (m == NULL) return; /* Add a symbolic constant */ d = PyModule_GetDict(m); - ThreadError = PyErr_NewException("thread.error", NULL, NULL); + ThreadError = PyErr_NewException("_thread.error", NULL, NULL); PyDict_SetItemString(d, "error", ThreadError); Locktype.tp_doc = lock_doc; Py_INCREF(&Locktype); diff --git a/PC/VC6/pythoncore.dsp b/PC/VC6/pythoncore.dsp index 84a5bb5586f..035a11da594 100644 --- a/PC/VC6/pythoncore.dsp +++ b/PC/VC6/pythoncore.dsp @@ -679,7 +679,7 @@ SOURCE=..\..\Python\thread.c # End Source File # Begin Source File -SOURCE=..\..\Modules\threadmodule.c +SOURCE=..\..\Modules\_threadmodule.c # End Source File # Begin Source File diff --git a/PC/VS7.1/pythoncore.vcproj b/PC/VS7.1/pythoncore.vcproj index 38982f4ddc4..8692e7a36c5 100644 --- a/PC/VS7.1/pythoncore.vcproj +++ b/PC/VS7.1/pythoncore.vcproj @@ -768,7 +768,7 @@ RelativePath="..\..\Python\thread.c"> + RelativePath="..\..\Modules\_threadmodule.c"> diff --git a/PC/VS8.0/pythoncore.vcproj b/PC/VS8.0/pythoncore.vcproj index 75414ce5a24..c2eb3561f7c 100644 --- a/PC/VS8.0/pythoncore.vcproj +++ b/PC/VS8.0/pythoncore.vcproj @@ -1127,7 +1127,7 @@ >