bpo-31370: Remove references to threadless builds (#8805)

ZackerySpytz · briancurtin · commit eef059657d6b · 2018-09-29T10:07:11.000-06:00
Support for threadless builds was removed in a6a4dc8.
diff --git a/Doc/c-api/init.rst b/Doc/c-api/init.rst
@@ -842,18 +842,18 @@ code, or when embedding the Python interpreter:
 
 .. c:function:: PyThreadState* PyEval_SaveThread()
 
-   Release the global interpreter lock (if it has been created and thread
-   support is enabled) and reset the thread state to *NULL*, returning the
-   previous thread state (which is not *NULL*).  If the lock has been created,
-   the current thread must have acquired it.
+   Release the global interpreter lock (if it has been created) and reset the
+   thread state to *NULL*, returning the previous thread state (which is not
+   *NULL*).  If the lock has been created, the current thread must have
+   acquired it.
 
 
 .. c:function:: void PyEval_RestoreThread(PyThreadState *tstate)
 
-   Acquire the global interpreter lock (if it has been created and thread
-   support is enabled) and set the thread state to *tstate*, which must not be
-   *NULL*.  If the lock has been created, the current thread must not have
-   acquired it, otherwise deadlock ensues.
+   Acquire the global interpreter lock (if it has been created) and set the
+   thread state to *tstate*, which must not be *NULL*.  If the lock has been
+   created, the current thread must not have acquired it, otherwise deadlock
+   ensues.
 
 
 .. c:function:: PyThreadState* PyThreadState_Get()
diff --git a/Doc/library/queue.rst b/Doc/library/queue.rst
@@ -11,9 +11,7 @@
 The :mod:`queue` module implements multi-producer, multi-consumer queues.
 It is especially useful in threaded programming when information must be
 exchanged safely between multiple threads.  The :class:`Queue` class in this
-module implements all the required locking semantics.  It depends on the
-availability of thread support in Python; see the :mod:`threading`
-module.
+module implements all the required locking semantics.
 
 The module implements three types of queue, which differ only in the order in
 which the entries are retrieved.  In a :abbr:`FIFO (first-in, first-out)`
diff --git a/Lib/test/_test_multiprocessing.py b/Lib/test/_test_multiprocessing.py
@@ -30,9 +30,6 @@
 _multiprocessing = test.support.import_module('_multiprocessing')
 # Skip tests if sem_open implementation is broken.
 test.support.import_module('multiprocessing.synchronize')
-# import threading after _multiprocessing to raise a more relevant error
-# message: "No module named _multiprocessing". _multiprocessing is not compiled
-# without thread support.
 import threading
 
 import multiprocessing.connection
diff --git a/Python/ceval.c b/Python/ceval.c
@@ -237,18 +237,14 @@ PyEval_ReInitThreads(void)
 }
 
 /* This function is used to signal that async exceptions are waiting to be
-   raised, therefore it is also useful in non-threaded builds. */
+   raised. */
 
 void
 _PyEval_SignalAsyncExc(void)
 {
     SIGNAL_ASYNC_EXC();
 }
 
-/* Functions save_thread and restore_thread are always defined so
-   dynamically loaded modules needn't be compiled separately for use
-   with and without threads: */
-
 PyThreadState *
 PyEval_SaveThread(void)
 {

Original file line number	Diff line number	Diff line change
`@@ -237,18 +237,14 @@ PyEval_ReInitThreads(void)`
`237`	`237`	`}`
`238`	`238`
`239`	`239`	`/* This function is used to signal that async exceptions are waiting to be`
`240`		`- raised, therefore it is also useful in non-threaded builds. */`
	`240`	`+ raised. */`
`241`	`241`
`242`	`242`	`void`
`243`	`243`	`_PyEval_SignalAsyncExc(void)`
`244`	`244`	`{`
`245`	`245`	`SIGNAL_ASYNC_EXC();`
`246`	`246`	`}`
`247`	`247`
`248`		`-/* Functions save_thread and restore_thread are always defined so`
`249`		`- dynamically loaded modules needn't be compiled separately for use`
`250`		`- with and without threads: */`
`251`		`-`
`252`	`248`	`PyThreadState *`
`253`	`249`	`PyEval_SaveThread(void)`
`254`	`250`	`{`