Release any acquired resources.
430597
protected void localRelease()
    {
        super.localRelease();

        _state.clear();
        _linkName = null;
        _clientAction = null;

        _action = null;
        _href = null;
        _targetScope = null;
        _location = null;
        _params = null;
        _form = null;
        _formSubmit = false;
        _popupSupport = null;
        _disableSecondClick = false;
    }
763128
public void releaseResources(List<ResourceRequest> released)
    throws IOException {
    if (failException != null) {
      throw failException;
    }

    List<Integer> releasedIds = new ArrayList<Integer>();
    for (ResourceRequest req : released) {
      releasedIds.add(req.getId());
    }
    cmNotifier.addCall(
        new ClusterManagerService.releaseResource_args(sessionId, releasedIds));
  }
1214009
def release(self, device_info):
        """"""
        if _debug: DeviceInfoCache._debug("release %r", device_info)

        # this information record might be used by more than one SSM
        if device_info._ref_count == 0:
            raise RuntimeError("reference count")

        # decrement the reference count
        device_info._ref_count -= 1
1223436
def close(self):
        
        files = self.__dict__.get('files')
        for key, value in iter_multi_items(files or ()):
            value.close()
310155
def release(self) -> None:
        """"""
        if self._value >= self._initial_value:
            raise ValueError("Semaphore released too many times")
        super(BoundedSemaphore, self).release()
1250685
private function release()
    {
        \assert($this->busy !== null);

        $deferred = $this->busy;
        $this->busy = null;
        $deferred->resolve();
    }
949516
public void releaseExternalResources() {

        if (!isClosed.get()) {
            logger.info("Releasing all ParallelClient resources... ");
            ActorConfig.shutDownActorSystemForce();
            httpClientStore.shutdown();
            tcpSshPingResourceStore.shutdown();
            cleanWaitTaskQueue();
            cleanInprogressJobMap();
            isClosed.set(true);
            logger.info("Have released all ParallelClient resources "
                    + "(actor system + async+sync http client + task queue)"
                    + "\nNow safe to stop your application.");

        } else {
            logger.debug("NO OP. ParallelClient resources have already been released.");
        }

    }
1148171
def release(self):
        
        if self.errored:
            self.pool.delete_resource(self)
        else:
            self.pool.release(self)
718936
public void free()
    {
        if (m_env != null)
        {
            m_env.removeApplication(this);
            m_env.freeIfDone();
        }
        
        super.free();

        if (m_databaseCollection != null)
            m_databaseCollection.free();
        m_databaseCollection = null;

        m_env = null;

        m_resources = null;
    }
385482
def release(self):
        ""
        if self._waiters:
            scheduler.state.awoken_from_events.add(self._waiters.popleft())
        else:
            self._value += 1
419206
function() {
      this.emit('acquiring');
      const onAcquisitionError = (err) => {
        logger.debug('Resource acquisition failed with error', err);
        this.emit('failed', err);
        this.handle('failed');
      };
      const onAcquired = (o) => {
        this.item = o;
        this.waitInterval = 0;
        if (this.item.on) {
          this.disposeHandle = this.item.once(disposalEvent || 'close', (err) => {
            logger.info('Resource lost, releasing', err);
            this.emit('lost');
            this.transition('released');
          });
          this.item.once('error', (err) => {
            logger.info('Resource error', err);
            this.transition('failed');
          });
          this.item.on('drain', () => {
            this.emit('drain');
          });
        }
        this.transition('acquired');
      };
      const onException = (ex) => {
        logger.debug('Resource acquisition failed with exception', ex);
        this.emit('failed', ex);
        this.handle('failed');
      };
      factory()
        .then(onAcquired, onAcquisitionError)
        .catch(onException);
    }
7077
@Override
	void releaseAllResources() throws IOException {
		if (!isReleased) {
			isReleased = true;

			ResultSubpartitionView view = subpartitionView;
			if (view != null) {
				view.releaseAllResources();
				subpartitionView = null;
			}
		}
	}
446150
def acquire(self, resources, prop_name):
        

        # Instance
        custom_prop = getattr(self.props, prop_name, None)
        if custom_prop:
            return custom_prop

        # Parents...can't use acquire as have to keep going on acquireds
        for parent in self.parents(resources):
            acquireds = parent.props.acquireds
            if acquireds:
                # First try in the per-type acquireds
                rtype_acquireds = acquireds.get(self.rtype)
                if rtype_acquireds:
                    prop_acquired = rtype_acquireds.get(prop_name)
                    if prop_acquired:
                        return prop_acquired

                # Next in the "all" section of acquireds
                all_acquireds = acquireds.get('all')
                if all_acquireds:
                    prop_acquired = all_acquireds.get(prop_name)
                    if prop_acquired:
                        return prop_acquired

        return
19482
public synchronized void release()
    {
        _list=null;
        _entry=null;
        _file=null;
        _jarFile=null;
        super.release();
    }
886568
public function release()
    {
        if ($this->handle) {
            flock($this->handle, LOCK_UN | LOCK_NB);
            fclose($this->handle);
            $this->handle = null;
        }
    }
724585
async def release(self) -> None:
        """"""
        while not self._at_eof:
            item = await self.next()
            if item is None:
                break
            await item.release()
1371782
@Override
	void releaseAllResources() throws IOException {
		if (isReleased.compareAndSet(false, true)) {

			// Gather all exclusive buffers and recycle them to global pool in batch, because
			// we do not want to trigger redistribution of buffers after each recycle.
			final List<MemorySegment> exclusiveRecyclingSegments = new ArrayList<>();

			synchronized (receivedBuffers) {
				Buffer buffer;
				while ((buffer = receivedBuffers.poll()) != null) {
					if (buffer.getRecycler() == this) {
						exclusiveRecyclingSegments.add(buffer.getMemorySegment());
					} else {
						buffer.recycleBuffer();
					}
				}
			}
			synchronized (bufferQueue) {
				bufferQueue.releaseAll(exclusiveRecyclingSegments);
			}

			if (exclusiveRecyclingSegments.size() > 0) {
				inputGate.returnExclusiveSegments(exclusiveRecyclingSegments);
			}

			// The released flag has to be set before closing the connection to ensure that
			// buffers received concurrently with closing are properly recycled.
			if (partitionRequestClient != null) {
				partitionRequestClient.close(this);
			} else {
				connectionManager.closeOpenChannelConnections(connectionId);
			}
		}
	}