code: def acquire(self):
          
          if os.path.exists(self.path):
              try:
                  pid = None
  
                  with open(self.path, 'r') as f:
                      line = f.readline().strip()
                      pid = int(line)
  
                  # In the case that the lockfile exists, but the pid does not
                  # correspond to a valid process, remove the file.
                  if not psutil.pid_exists(pid):
                      os.remove(self.path)
  
              except ValueError as e:
                  # Pidfile is invalid, so just delete it.
                  os.remove(self.path)
  
              except IOError as e:
                  # Something happened while trying to read/remove the file, so
                  # skip trying to read/remove it.
                  pass
  
          try:
              self.fd = os.open(self.path, os.O_CREAT | os.O_EXCL | os.O_RDWR)
  
              # PID is written to the file, so that if a process exits wtihout
              # cleaning up the lockfile, we can still acquire the lock.
              to_write = '%s%s' % (os.getpid(), os.linesep)
              os.write(self.fd, to_write.encode())
  
          except OSError as e:
              if not os.path.exists(self.path):
                  raise
              return False
  
          self.acquired = True
          return True
docs: Attempts to acquire a lock for the J-Link lockfile.
  
          If the lockfile exists but does not correspond to an active process,
          the lockfile is first removed, before an attempt is made to acquire it.
  
          Args:
            self (Jlock): the ``JLock`` instance
  
          Returns:
            ``True`` if the lock was acquired, otherwise ``False``.
  
          Raises:
            OSError: on file errors.