Merge.

Doc/library/multiprocessing.rst

@@ -1172,12 +1172,24 @@ inherited by child processes.
    ctypes type or a one character typecode of the kind used by the :mod:`array`
    module.  *\*args* is passed on to the constructor for the type.
 
-   If *lock* is ``True`` (the default) then a new lock object is created to
+   If *lock* is ``True`` (the default) then a new recursive lock
-   synchronize access to the value.  If *lock* is a :class:`Lock` or
+   object is created to synchronize access to the value.  If *lock* is
-   :class:`RLock` object then that will be used to synchronize access to the
+   a :class:`Lock` or :class:`RLock` object then that will be used to
-   value.  If *lock* is ``False`` then access to the returned object will not be
+   synchronize access to the value.  If *lock* is ``False`` then
-   automatically protected by a lock, so it will not necessarily be
+   access to the returned object will not be automatically protected
-   "process-safe".
+   by a lock, so it will not necessarily be "process-safe".
+
+   Operations like ``+=`` which involve a read and write are not
+   atomic.  So if, for instance, you want to atomically increment a
+   shared value it is insufficient to just do ::
+
+       counter.value += 1
+
+   Assuming the associated lock is recursive (which it is by default)
+   you can instead do ::
+
+       with counter.get_lock():
+           counter.value += 1
 
    Note that *lock* is a keyword-only argument.