Release the lock.
16480
def release(self):
        
        query = 'DELETE FROM {cf} WHERE "lockId"=:lockId AND "claimId"=:claimId;'
        d = self._client.execute(query.format(cf=self._lock_table),
                                 {'lockId': self._lock_id, 'claimId': self._claim_id},
                                 ConsistencyLevel.QUORUM)

        def _log_release_time(result):
            if self._log and self._lock_acquired_seconds is not None:
                seconds = self._reactor.seconds() - self._lock_acquired_seconds
                self._log.msg('Released lock. Was held for {0} seconds'.format(seconds),
                              lock_held_time=seconds, result=result, **self._log_kwargs)
            return result

        return d.addBoth(_log_release_time)
443067
def release(self, conn):
        """"""
        self._pool_lock.acquire()
        self._pool.put(ConnectionWrapper(self._pool, conn))
        self._current_acquired -= 1
        self._pool_lock.release()
1048027
def release(self):
        ""
        if self.acquired_until is None:
            raise ValueError("Cannot release an unlocked lock")
        existing = float(self.redis.get(self.name) or 1)
        # if the lock time is in the future, delete the lock
        if existing >= self.acquired_until:
            self.redis.delete(self.name)
        self.acquired_until = None
964960
def release(self):
        
        if self._lock_fd is not None:
            os.close(self._lock_fd)
            try:
                os.remove(self._lock_filename)
            except OSError:
                # Hmm, someone deleted our lock while we had it locked?
                # Nothing we can do, so just continue
                pass
978347
def release(self, connection):
        
        with self.lock:
            connection.in_use = False
            self.cond.notify_all()
1311929
def _release_all(self):
        """"""
        for i in self.inputs:
            i.call_release(True)
        self.available_lock.release()
1075263
public final void release() {
		synchronized (this.LOCK) {
			if ((this.owner != null)
					&& (this.owner.get() == Thread.currentThread())) {
				this.acquire--;

				if (this.acquire == 0) {
					this.owner = null;
					this.LOCK.notify();
				}

				return;
			}

			if ((this.owner != null) && (this.owner.get() == null)) {
				this.owner = null;
				this.acquire = 0;
				this.LOCK.notify();
			}

			throw new IllegalMonitorStateException(Thread.currentThread()
					.getName()
					+ " is not the owner of the lock. "
					+ ((this.owner != null) ? ((Thread) this.owner.get())
							.getName() : "nobody") + " is the owner.");
		}
	}
81981
public synchronized void release()
    {
        if (_in!=null)
        {
            try{_in.close();}catch(IOException e){LogSupport.ignore(log,e);}
            _in=null;
        }

        if (_connection!=null)
            _connection=null;
    }
1266450
public void release() {
	this.base = null;
	current = root;
	current.body = null;
	current.after = null;
	current.before = null;
    }
821764
private void takeCloseLock()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "takeCloseLock");

      while (true)
      {
         try
         {
            closeLock.readLock().lockInterruptibly();
            break;
         }
         catch (InterruptedException e)
         {
            // No FFDC code needed.
         }
      }

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "takeCloseLock");
   }
355257
def release(self, elt):
        
        self.lock.acquire()
        try:
            if elt not in self.locked:
                raise thread.error, "release unlocked lock for %s" % `elt`
            self.locked[elt][1] -= 1
            if not self.locked[elt][1]:
                del self.locked[elt]
        finally:
            self.lock.release()
943570
private void releaseCloseLock()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "releaseCloseLock");
      closeLock.readLock().unlock();
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "releaseCloseLock");
   }
445965
public function release()
    {
        $this->redis->eval(LuaScripts::releaseLock(), 1, $this->name, $this->owner);
    }
469735
public function release() {
        if (!$this->releaser) {
            return;
        }

        // Invoke the releaser function given to us by the synchronization source
        // to release the lock.
        $releaser = $this->releaser;
        $this->releaser = null;
        ($releaser)($this);
    }
662512
public function release()
    {
        if (!$this->handler) {
            throw new \LogicException('Lock is not acquired');
        }
        if (!@ftruncate($this->handler, 0)) {
            $this->throwLastErrorException();
        }
        if (!flock($this->handler, LOCK_UN)) {
            throw new \RuntimeException(sprintf('Unable to release lock on %s', $this->file));
        }
        $this->closeFile();
    }
83892
def __unLock(self):
        """"""
        self._operation = False
        self._timer = 0
        self._isLocked = False
64595
public void release() {

    parent = null;
    firstChild = null;
    prevSibling = null;
    nextSibling = null;
    allowChildren = true;
  }