Releases resources used by this instance.
180373
public void close() {
    if (gcs != null) {
      logger.atFine().log("close()");
      try {
        gcs.close();
      } finally {
        gcs = null;

        if (updateTimestampsExecutor != null) {
          try {
            shutdownExecutor(updateTimestampsExecutor, /* waitSeconds= */ 10);
          } finally {
            updateTimestampsExecutor = null;
          }
        }

        if (cachedExecutor != null) {
          try {
            shutdownExecutor(cachedExecutor, /* waitSeconds= */ 5);
          } finally {
            cachedExecutor = null;
          }
        }
      }
    }
  }
1050867
public void free()
    {
        super.free();
        try
        {
            if (this.getHandle(DBConstants.DATA_SOURCE_HANDLE) != null)
                ((BaseBuffer)this.getHandle(DBConstants.DATA_SOURCE_HANDLE)).free();
        } catch (DBException ex)    {
            // Never
        }
        if (m_pTable != null)
            m_pTable.removePTableOwner(this, true);      // Free or decrement the use count of the physical table
        m_pTable = null;
    }
1311629
public synchronized void release() {
        Enumeration ptdE=threadData.keys();
        while( ptdE.hasMoreElements() ) {
            PerThreadData ptd=(PerThreadData)ptdE.nextElement();
            for (int i=ptd.current; i>=0; i--) {
                if( ptd.handlers != null && ptd.handlers[i]!=null )
                    ptd.handlers[i].release();
            }
        }
    }
721004
public void destroyResources() {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "destroyResources");

        // Browse through the participants, processing them as appropriate
        final ArrayList<JTAResource> resources = getResourceObjects();
        for (JTAResource resource : resources) {
            destroyResource(resource);
        }

        if (_sameRMResource != null) {
            destroyResource(_sameRMResource);
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "destroyResources");
    }
41374
@Override
    final public void cleanup() throws ResourceException {

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, "cleanup");
        }

        // Invalidate all of the sessions

        for (final Iterator iterator = _sessions.iterator(); iterator.hasNext();) {
            final Object object = iterator.next();
            if (object instanceof JmsJcaSessionImpl) {
                ((JmsJcaSessionImpl) object).invalidate();
            }
        }
        _sessions.clear();

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, "cleanup");
        }

    }
445732
public void releaseAllResources()
    {
        synchronized (poolSynch)
        {
            Collection pools = poolMap.values();
            poolMap = new HashMap(poolMap.size());
            ObjectPool op = null;
            for (Iterator iterator = pools.iterator(); iterator.hasNext();)
            {
                try
                {
                    op = ((ObjectPool) iterator.next());
                    op.close();
                }
                catch (Exception e)
                {
                    log.error("Exception occured while closing pool " + op, e);
                }
            }
        }
        super.releaseAllResources();
    }
747576
public function cleanup(): void
    {
        foreach ($this->getStore() as $key => $value)
        {
            $this->remove($key);
        }
    }
64595
public void release() {

    parent = null;
    firstChild = null;
    prevSibling = null;
    nextSibling = null;
    allowChildren = true;
  }
1266450
public void release() {
	this.base = null;
	current = root;
	current.body = null;
	current.after = null;
	current.before = null;
    }
840798
def close(self):
        
        if self._resource is not None:
            self._pool.put_resource(self._resource)
            self._resource = None
            self._pool = None
817460
public void dispose() {
		singleton.clear();
		components.clear();
		pointcuts.clear();
		contexts.clear();
		instances.clear();
	}
1364072
public void clear() {

        if (staticResourceHandlers != null) {
            staticResourceHandlers.clear();
            staticResourceHandlers = null;
        }

        staticResourcesSet = false;
        externalStaticResourcesSet = false;
    }
77735
@Override
  public void close() throws IOException {
    try {
      mLock.lock();
      if (mAvailableResources.size() != mResources.size()) {
        LOG.warn("{} resources are not released when closing the resource pool.",
            mResources.size() - mAvailableResources.size());
      }
      for (ResourceInternal<T> resourceInternal : mAvailableResources) {
        closeResource(resourceInternal.mResource);
      }
      mAvailableResources.clear();
    } finally {
      mLock.unlock();
    }
    mGcFuture.cancel(true);
  }
790194
void release() {
    long references = --this.references;
    if (!state.active() && references == 0) {
      context.sessions().unregisterSession(id);
      log.release(id);
      if (closeIndex > 0) {
        log.release(closeIndex);
      }
    }
  }
804914
def destroy(self):
        """"""
        r = api.Resources(self.provider_conf.to_dict())
        # insert force_deploy
        r.destroy()
56511
public static void dispose() {

    if (xml2containerMap != null) {
      for (SpringContainer container : xml2containerMap.values()) {
        container.dispose();
      }
      xml2containerMap.clear();
    }
  }
461461
public void releaseResources() {
		for (InputStream str : fis) {
			try {
				str.close();
			} catch (Exception e) {
				LOG.info("Exception while trying to close streams", e);
			}
		}
	}