Rename thread to _thread and dummy_thread to _dummy_thread. Issue #2875.
diff --git a/Doc/c-api/exceptions.rst b/Doc/c-api/exceptions.rst
index 9c9ee7f..7440dda 100644
--- a/Doc/c-api/exceptions.rst
+++ b/Doc/c-api/exceptions.rst
@@ -351,7 +351,7 @@
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 4bf6445..864991e 100644
--- a/Doc/c-api/init.rst
+++ b/Doc/c-api/init.rst
@@ -539,7 +539,7 @@
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 @@
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 9f47516..8ea61b0 100644
--- a/Doc/c-api/typeobj.rst
+++ b/Doc/c-api/typeobj.rst
@@ -488,7 +488,7 @@
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 0000000..62e5708
--- /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 31d58e7..95214d6 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 @@
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 @@
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 0b2cb17..0000000
--- 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 0ffb687..0658df2 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 5ee96bc..160ce48 100644
--- a/Doc/library/someos.rst
+++ b/Doc/library/someos.rst
@@ -14,10 +14,10 @@
.. 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 6be2f62..2381f24 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 @@
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