class_docstr: asyncio reentrant lock, which allows the same owner (or two owners that compare
  as equal) to be inside the critical section at the same time.
  
  Note that here the owner is an explicit, generic object, whereas in
  :func:`threading.RLock` and :func:`multiprocessing.RLock` it's hardcoded
  respectively to the thread ID and process ID.
  
  **Usage**::
  
      lock = RLock()
      async with lock("my-owner"):
          ...
  
  **Tip**
  
  You can mix reentrant and non-reentrant owners; all you need to do is create an
  owner that doesn't compare as equal to other instances of itself::
  
      lock = RLock()
  
      async def non_reentrant():
          async with lock(object()):
              ...
  
      async def reentrant():
          async with lock("foo"):
              ...
  
  In the above example, at any time you may have inside the critical section
  at most one call to ``non_reentrant`` and no calls to ``reentrant``, or any number
  of calls to ``reentrant`` but no calls to ``non_reentrant``.
code: def __init__(self):
      self._owner = None
      self._count = 0
      self._lock = asyncio.Lock()
  
imports: from __future__ import annotations
  import asyncio
  from collections.abc import AsyncIterator
  from contextlib import asynccontextmanager
label_desc: Use image node_id 1 to create a new RLock object  with example: obj = RLock()