gh-142518: Define lock-free and per-object lock

- Add definitions of lock-free and per-object lock to the glossary
- Cross-reference these from list thread safety notes
- Change admonition to rubric

Author: lysnikolaou

Doc/glossary.rst

@@ -951,6 +951,16 @@ Glossary
       to locks exist such as queues, producer/consumer patterns, and
       thread-local state. See also :term:`deadlock`, and :term:`reentrant`.
 
+   lock-free
+      An operation that does not acquire any :term:`lock` and uses atomic CPU
+      instructions to ensure correctness. Lock-free operations can execute
+      concurrently without blocking each other and cannot be blocked by
+      operations that hold locks. In :term:`free-threaded <free threading>`
+      Python, built-in types like :class:`dict` and :class:`list` provide
+      lock-free read operations, which means other threads may observe
+      intermediate states during multi-step modifications even when those
+      modifications hold the :term:`per-object lock`.
+
    loader
       An object that loads a module.
       It must define the :meth:`!exec_module` and :meth:`!create_module` methods
@@ -1217,6 +1227,16 @@ Glossary
       <faq-argument-vs-parameter>`, the :class:`inspect.Parameter` class, the
       :ref:`function` section, and :pep:`362`.
 
+   per-object lock
+      A :term:`lock` associated with an individual object instance rather than
+      a global lock shared across all objects. In :term:`free-threaded
+      <free threading>` Python, built-in types like :class:`dict` and
+      :class:`list` use per-object locks to allow concurrent operations on
+      different objects while serializing operations on the same object.
+      Operations that hold the per-object lock prevent other locking operations
+      on the same object from proceeding, but do not block :term:`lock-free`
+      operations.
+
    path entry
       A single location on the :term:`import path` which the :term:`path
       based finder` consults to find modules for importing.

Doc/library/stdtypes.rst

@@ -1441,7 +1441,9 @@ application).
          list appear empty for the duration, and raises :exc:`ValueError` if it can
          detect that the list has been mutated during a sort.
 
-.. admonition:: Thread safety
+.. _thread-safety-list:
+
+.. rubric:: Thread safety for list objects
 
    Reading a single element from a :class:`list` is
    :term:`atomic <atomic operation>`:
@@ -1462,11 +1464,11 @@ application).
       lst.index(item)
       lst.count(item)
 
-   All of the above methods/operations are also lock-free. They do not block
-   concurrent modifications. Other operations that hold a lock will not block
-   these from observing intermediate states.
+   All of the above methods/operations are also :term:`lock-free`. They do not
+   block concurrent modifications. Other operations that hold a lock will not
+   block these from observing intermediate states.
 
-   All other operations from here on block using the per-object lock.
+   All other operations from here on block using the :term:`per-object lock`.
 
    Writing a single item via ``lst[i] = x`` is safe to call from multiple
    threads and will not corrupt the list.
@@ -1497,7 +1499,7 @@ application).
    Other threads cannot observe intermediate states during sorting, but the
    list appears empty for the duration of the sort.
 
-   The following operations may allow lock-free operations to observe
+   The following operations may allow :term:`lock-free` operations to observe
    intermediate states since they modify multiple elements in place:
 
    .. code-block::