code: def acquire(self, blocking=1):
          
          me = _get_ident()
          if self.__owner == me:
              self.__count = self.__count + 1
              if __debug__:
                  self._note("%s.acquire(%s): recursive success", self, blocking)
              return 1
          rc = self.__block.acquire(blocking)
          if rc:
              self.__owner = me
              self.__count = 1
              if __debug__:
                  self._note("%s.acquire(%s): initial success", self, blocking)
          else:
              if __debug__:
                  self._note("%s.acquire(%s): failure", self, blocking)
          return rc
docs: Acquire a lock, blocking or non-blocking.
  
          When invoked without arguments: if this thread already owns the lock,
          increment the recursion level by one, and return immediately. Otherwise,
          if another thread owns the lock, block until the lock is unlocked. Once
          the lock is unlocked (not owned by any thread), then grab ownership, set
          the recursion level to one, and return. If more than one thread is
          blocked waiting until the lock is unlocked, only one at a time will be
          able to grab ownership of the lock. There is no return value in this
          case.
  
          When invoked with the blocking argument set to true, do the same thing
          as when called without arguments, and return true.
  
          When invoked with the blocking argument set to false, do not block. If a
          call without an argument would block, return false immediately;
          otherwise, do the same thing as when called without arguments, and
          return true.