Releases the exclusive lock.

@exception NoExclusiveLockException The caller does not hold the exclusive lock.
194358
public void releaseExclusiveLock() throws NoExclusiveLockException
  {
    if (tc.isEntryEnabled()) Tr.entry(tc, "releaseExclusiveLock",this);

    Thread currentThread = Thread.currentThread();

    synchronized(this)
    {
      if ((_threadHoldingExclusiveLock == null) || (!_threadHoldingExclusiveLock.equals(currentThread)))
      {
        if (tc.isEntryEnabled()) Tr.exit(tc, "releaseExclusiveLock", "NoExclusiveLockException");
        throw new NoExclusiveLockException();
      }

      _threadHoldingExclusiveLock = null;
      _threadRequestingExclusiveLock = null;

      // There may be thread waiting for the exclusive lock to be released. Notify them of this event.
      this.notifyAll();
    }

    if (tc.isEntryEnabled()) Tr.exit(tc, "releaseExclusiveLock");
  }
1264834
private void releaseConnection()
   {
      if (m_rs != null)
      {
         try
         {
            m_rs.close();
         }

         catch (SQLException ex)
         {
            // silently ignore errors on close
         }

         m_rs = null;
      }

      if (m_ps != null)
      {
         try
         {
            m_ps.close();
         }

         catch (SQLException ex)
         {
            // silently ignore errors on close
         }

         m_ps = null;
      }
   }
853302
@Override
	public void release() {
		super.release();
		setSrcExpr(null);
		setUseRandomParamExpr(null);
		setMediaExpr(null);
		setTitleExpr(null);
		setAlternateExpr(null);
		setDisplayAlternateExpr(null);
	}
933094
public void release() {
        if (released.compareAndSet(false, true)) {
            synchronized (releasingLock) {
                if (released.get()) {
                    impl.release(Integer.MAX_VALUE);
                }
            }
        }
    }
339947
public void release() {
        try {
            if(hasCoreConnection()) {
                checkThreadBinding();
                this.setClosed(true);
                this.getCoreConnection().reset();
                this.fireConnectionReleased();

            }
        } finally {
            this.setClosed(true);

            // state may be important for Stat-Listener, so its set after the listener did their work
            setTransactionalData(false);

            this.releaseThreadBinding();
        }
    }
1040946
public function release()
    {
        if ($this->handle) {
            $released = flock($this->handle, LOCK_UN);
            fclose($this->handle);
            $this->handle = null;

            if (!$released) {
                throw new \RuntimeException('Failed to release lock.');
            }
        }
    }
1129793
public synchronized void lock()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "lock", this);

    boolean interrupted = false;

    // Attempt to get a lock on the mutex.
    // if we fail, then that is because the lock
    // must be held exclusively.
    while (!tryLock())
      try
      {
        // Wait for 1 second then try again.
        if (tc.isDebugEnabled())
          SibTr.debug(tc, "Waiting for lock");
        wait(1000);
      }
      catch (InterruptedException e)
      {
        // No FFDC code needed
        interrupted = true;
      }

    if (interrupted)
      Thread.currentThread().interrupt();

    if (tc.isEntryEnabled())
      SibTr.exit(tc, "lock");

  }
801579
public final void release()
                    throws java.io.IOException {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this,
                        cclass,
                        "release");

        // Give up the lock.
        if (fileLock != null)
            fileLock.release();
        fileLock = null;

        if (fileChannel != null)
            fileChannel.close();
        fileChannel = null;

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this,
                       cclass,
                       "release");
    }
886568
public function release()
    {
        if ($this->handle) {
            flock($this->handle, LOCK_UN | LOCK_NB);
            fclose($this->handle);
            $this->handle = null;
        }
    }
840236
def release(self):
		
		if self._locked is True:
			self._locked = False
			self._lock.release()
1136574
public void releaseExceptionallyAndReset(Throwable e) {
        ArrayList<CompletableFuture<T>> toComplete = null;
        synchronized (lock) {
            if (!waitingFutures.isEmpty()) {
                toComplete = new ArrayList<>(waitingFutures);
                waitingFutures.clear();
            }
            released = false;
            this.e = null;
            result = null;
            runningThreadId = null;
        }
        if (toComplete != null) {
            for (CompletableFuture<T> f : toComplete) {
                f.completeExceptionally(e);
            }
        }
    }
1274605
public void acquireAllLocks(List<Object> keys, boolean exclusive) {
      for (Object k : keys) {
        acquireLock(k, exclusive);
    }
   }
1023201
@Override
    public void release() {
	params.clear();
	results.clear();
	returnValue = null;
	procedure = null;
	datasource = null;
	username = null;
	password = null;
	blockfactor = -1;
	timeout = -1;
	debug = true;
	returncode = false;
	result = "cfstoredproc";

	cachedWithin = null;
	cachedafter = null;
	// cachename="";

	super.release();
    }
435790
private boolean releaseFileLock() {

        // Note:  Closing the super class RandomAccessFile has the
        //        side-effect of closing the file lock's FileChannel,
        //        so we do not deal with this here.
        boolean success = false;

        if (this.fileLock == null) {
            success = true;
        } else {
            try {
                this.fileLock.release();

                success = true;
            } catch (Exception e) {}
            finally {
                this.fileLock = null;
            }
        }

        return success;
    }
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");
   }
199808
@Override
	public void close(@NotNull Throwable e) {
		if (exception != null) return;
		exception = e instanceof Exception ? (Exception) e : new RuntimeException(e);
		if (put != null) {
			put.setException(e);
			put = null;
		}
		if (take != null) {
			take.setException(e);
			take = null;
		}
		for (int i = head; i != tail; i = (i + 1) & (elements.length - 1)) {
			tryRecycle(elements[i]);
		}
		//noinspection AssignmentToNull - resource release
		elements = null;
	}
836498
def release(self):
        
        lock = vars(self).pop('lock', missing)
        lock is not missing and self._release(lock)