Be consistent in the spelling of thread-safe(ty).

diff --git a/Doc/c-api/init.rst b/Doc/c-api/init.rst
index 1c621555e2bf3ab7e47b47d56666c73b06392c87..dbceecc931593ef342cc814bdf87051cd5f5a0ea 100644 (file)
--- a/Doc/c-api/init.rst
+++ b/Doc/c-api/init.rst
@@ -437,7 +437,7 @@ Thread State and the Global Interpreter Lock
    single: interpreter lock
    single: lock, interpreter
 
-The Python interpreter is not fully thread safe.  In order to support
+The Python interpreter is not fully thread-safe.  In order to support
 multi-threaded Python programs, there's a global lock, called the :dfn:`global
 interpreter lock` or :dfn:`GIL`, that must be held by the current thread before
 it can safely access Python objects. Without the lock, even the simplest

diff --git a/Doc/library/locale.rst b/Doc/library/locale.rst
index c15f7e3d828d852149fc42c5e391566aaea21ca8..a3a7b487b9cb07b8a676fbbaa7bf80480159ab0d 100644 (file)
--- a/Doc/library/locale.rst
+++ b/Doc/library/locale.rst
@@ -39,7 +39,7 @@ The :mod:`locale` module defines the following exception and functions:
    If *locale* is omitted or ``None``, the current setting for *category* is
    returned.
 
-   :func:`setlocale` is not thread safe on most systems. Applications typically
+   :func:`setlocale` is not thread-safe on most systems. Applications typically
    start with a call of ::
 
       import locale

diff --git a/Doc/library/multiprocessing.rst b/Doc/library/multiprocessing.rst
index 65c64e19b2ab0ec86d45b1e790d54218ff3d7780..aa1e752bc81c86b2f73a58c3baff36122cd2d3fe 100644 (file)
--- a/Doc/library/multiprocessing.rst
+++ b/Doc/library/multiprocessing.rst
@@ -214,7 +214,7 @@ However, if you really do need to use some shared data then
    The ``'d'`` and ``'i'`` arguments used when creating ``num`` and ``arr`` are
    typecodes of the kind used by the :mod:`array` module: ``'d'`` indicates a
    double precision float and ``'i'`` indicates a signed integer.  These shared
-   objects will be process and thread safe.
+   objects will be process and thread-safe.
 
    For more flexibility in using shared memory one can use the
    :mod:`multiprocessing.sharedctypes` module which supports the creation of

diff --git a/Doc/library/runpy.rst b/Doc/library/runpy.rst
index 71f896f4c36d70420fb941e499b4cff3b645652f..896b65d44b595ec6003e859970fa03139a613334 100644 (file)
--- a/Doc/library/runpy.rst
+++ b/Doc/library/runpy.rst
@@ -120,7 +120,7 @@ The :mod:`runpy` module provides two functions:
 
    Note that, unlike :func:`run_module`, the alterations made to :mod:`sys`
    are not optional in this function as these adjustments are essential to
-   allowing the execution of sys.path entries. As the thread safety
+   allowing the execution of sys.path entries. As the thread-safety
    limitations still apply, use of this function in threaded code should be
    either serialised with the import lock or delegated to a separate process.
 

diff --git a/Doc/library/threading.rst b/Doc/library/threading.rst
index 3419e65c0e1cf99a7d31ef2a4390917375d4bf4c..3e2e1e3758a4c6d6cec99c55cc2a27e97bc7bebf 100644 (file)
--- a/Doc/library/threading.rst
+++ b/Doc/library/threading.rst
@@ -789,9 +789,9 @@ Currently, :class:`Lock`, :class:`RLock`, :class:`Condition`,
 Importing in threaded code
 --------------------------
 
-While the import machinery is thread safe, there are two key
-restrictions on threaded imports due to inherent limitations in the way
-that thread safety is provided:
+While the import machinery is thread-safe, there are two key restrictions on
+threaded imports due to inherent limitations in the way that thread-safety is
+provided:
 
 * Firstly, other than in the main module, an import should not have the
   side effect of spawning a new thread and then waiting for that thread in