Release the lock.
497970
public void unlock() {
		ArrayList<Runnable> list;
		Thread t = Thread.currentThread();
		synchronized (this) {
			if (t != lockingThread) return;
			if (--lockedTimes > 0) return;
			lockingThread = null;
			list = listeners;
			listeners = null;
		}
		if (list != null) {
			for (Runnable r : list) r.run();
		}
		// notify after listeners
		synchronized (this) {
			this.notifyAll();
		}
	}
661672
def unlock(self):
        
        if isinstance(self._session, manager.Manager):
            self._session.unlock()
6236
def unlock(self):
        
        logger.debug("Releasing lock %s", self.lock_file)
        self._lock.release()
        try:
            os.unlink(self.lock_file)
        except FileNotFoundError:
            pass
1236267
async function release(key) {
    const previousLocks = LOCKS_MAP.get(key) || [];
    const locksLength = previousLocks.length;

    log(
      'debug',
      `Releasing the lock on ${key} (queue length was ${locksLength})`,
    );
    previousLocks.pop().release();
  }
339776
public function releaseHandle()
    {
        if (is_resource($this->handle)) {
            fclose($this->handle);
        }
        $this->handle = null;
    }
64595
public void release() {

    parent = null;
    firstChild = null;
    prevSibling = null;
    nextSibling = null;
    allowChildren = true;
  }
92178
public void unlock()
  {
      if (tc.isEntryEnabled()) Tr.entry(tc, "unlock");

      if (_handle2 != null)
      {
        releaseLock(_handle2);
      }
      if (_handle1 != null)
      {
        releaseLock(_handle1);
      }

      _handle2=null;
      _handle1=null;

      if (tc.isEntryEnabled()) Tr.exit(tc, "unlock");
  }
565930
public function lock() {
        $this->primaryPrivateKey = null;
        $this->secret = null;
        $this->primarySeed = null;
        $this->locked = true;
    }
1339918
public function release()
    {
        if ($this->locked) {
            flock($this->fp, LOCK_UN);
            fclose($this->fp);

            $this->fp = null;
            $this->locked = false;
        }

        return $this;
    }
495321
def close(self):
        
        super(LockingDatabase, self).close()
        if not self.readonly:
            self.release_lock()
1311929
def _release_all(self):
        """"""
        for i in self.inputs:
            i.call_release(True)
        self.available_lock.release()
994743
function release() {
    if (this.isTrapped) {
        this.restoreTrap = this.state.open;
        screenReaderTrap.untrap(this.windowEl);
        keyboardTrap.untrap(this.windowEl);
    } else {
        this.restoreTrap = false;
    }
}
959297
def Release(self):
    
    if self.locked:
      query = ("UPDATE locks SET lock_expiration=0, lock_owner=0 "
               "WHERE lock_expiration=%s "
               "AND lock_owner=%s "
               "AND subject_hash=unhex(md5(%s))")
      args = [self.expires, self.lock_token, self.subject]
      self.store.ExecuteQuery(query, args)
      self.locked = False
595545
def release(self):
        
        if self._local.locked:
            while self._queue:
                future = self._queue.popleft()
                if not future.done():
                    return future.set_result(None)
            self._local.locked = None
        else:
            raise RuntimeError('release unlocked lock')
506238
public void release() throws Exception {
        synchronized (this) {
            if (log.isDebugEnabled()) {
                log.debug("Releasing lock on " + lockFile.getAbsolutePath());
            }
            if (fileLock != null) {
                try {
                    fileLock.release();
                    fileLock = null;
                } catch (Exception e) {
                    throw new Exception("Unable to release locked file: " + lockFile.getAbsolutePath(), e);
                }
                if (fileChannel != null) {
                    try {
                        fileChannel.close();
                    } catch (IOException e) {
                        // ignore
                    }
                    fileChannel = null;
                }
                if (lockFile != null) {
                    if (lockFile.exists()) {
                        lockFile.delete();
                    }
                    lockFile = null;
                }
            }
        }
    }
425408
public void release() {
        if (lock != null) {
            try {
                lock.release();
                lock = null;
            } catch (IOException ex) {
                LOGGER.debug("Failed to release lock", ex);
            }
        }
        if (file != null) {
            try {
                file.close();
                file = null;
            } catch (IOException ex) {
                LOGGER.debug("Unable to delete lock file", ex);
            }
        }
        if (lockFile != null && lockFile.isFile()) {
            final String msg = readLockFile();
            if (msg != null && msg.equals(magic) && !lockFile.delete()) {
                LOGGER.error("Lock file '{}' was unable to be deleted. Please manually delete this file.", lockFile.toString());
                lockFile.deleteOnExit();
            }
        }
        lockFile = null;
        removeShutdownHook();
        final Timestamp timestamp = new Timestamp(System.currentTimeMillis());
        LOGGER.debug("Lock released ({}) {} @ {}", Thread.currentThread().getName(), magic, timestamp.toString());
    }
836498
def release(self):
        
        lock = vars(self).pop('lock', missing)
        lock is not missing and self._release(lock)