docs: def acquire(self, blocking=True):
          """acquire ownership of the lock
  
          if the lock is already owned by the calling greenlet, a counter simply
          gets incremented. if it is owned by a different greenlet then it will
          block until the lock becomes available.
  
          .. note::
  
              this method will block the current coroutine if the lock is not
              already owned by another coroutine.
  
          :param blocking:
              whether to block if the lock is owned by a different greenlet
              (default ``True``)
          :type blocking: bool
  
          :returns:
              a `bool` indicating whether the lock was acquired. In the default
              case of ``blocking = True`` this will always be the case, but may
              not be otherwise.
          """
          current = compat.getcurrent()
          if self._owner is current:
              self._count += 1
              return True
          if self._locked and not blocking:
              return False
          if self._locked:
              self._waiters.append(compat.getcurrent())
              scheduler.state.mainloop.switch()
          else:
              self._locked = True
              self._owner = current
          self._count = 1
          return True