Release and free memory.
971859
function () {
    this.objectPool.recycle(this.attrValue);
    this.objectPool.recycle(this.oldData);
    this.objectPool.recycle(this.parsingAttrValue);
    this.attrValue = this.oldData = this.parsingAttrValue = undefined;
  }
775732
public void release()
    {
        super.release();

        _forceId = null;
        _forceIdIndex = null;

        _value = null;
        _converter = null;

        _javascriptLocation = null;
        _imageLocation = null;
        _styleLocation = null;
    }
8617
void release() {
		if (mCurrentRequests != null) {
			synchronized (mCurrentRequests) {
				mCurrentRequests.clear();
				mCurrentRequests = null;
			}
		}

		if (mDownloadQueue != null) {
			mDownloadQueue = null;
		}

		if (mDownloadDispatchers != null) {
			stop();

			for (int i = 0; i < mDownloadDispatchers.length; i++) {
				mDownloadDispatchers[i] = null;
			}
			mDownloadDispatchers = null;
		}

	}
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();
    }
806169
def free(self):
        
        # Free the memory
        self._machine_controller.sdram_free(self._start_address,
                                            self._x, self._y)

        # Mark as freed
        self._freed = True
1310403
public void free()
    {
        super.free();
        m_baOut = null;
        m_daOut = null;
        m_baIn = null;
        m_daIn = null;
    }
473636
def close(self) -> None:
        """"""
        if self.mmap is not None:
            self.mmap.close()

        try:
            os.close(self.fd)
        except OSError:
            pass
669027
public void release(Object o)
    {
        synchronized(this)
        {
            usedPool.remove(o);
            freePool.add(o);
            notify();
        }
    }
318332
public function freeMemory()
    {
        $this->_freeMemory();
        foreach ($this->_dataCache as $id=>$c) {
            if (isset($this->_dataCacheIgnoreVisible[$id])) {
                unset($this->_dataCacheIgnoreVisible[$id]);
            }
            $c->_freeMemory();
        }
        foreach ($this->_dataCacheIgnoreVisible as $id=>$c) {
            $c->_freeMemory();
        }
        $this->_dataCache = array();
        $this->_dataCacheIgnoreVisible = array();
        $this->_componentsByClassCache = null;
        $this->_componentsByDbIdCache = null;
        $this->_generatorsForClassesCache = array();
        //Kwf_Component_Generator_Abstract::clearInstances();
        Kwf_Model_Abstract::clearAllRows();

        if (function_exists('gc_collect_cycles')) gc_collect_cycles();
    }
1051431
public void free()
    {
        m_bookmark = null;
        m_objectID = null;
        m_dataSource = null;
        m_objectSource = null;
        if (m_buffer != null)
        {
            m_buffer.free();
            m_buffer = null;
        } 
    }
250112
public final void freeBuffers()
    {
        /* 11-Apr-2005, TSa: Ok, we can release the buffer now, to be
         *   recycled by the next stream reader instantiated by this
         *   thread (if any).
         */
	if (mRecycleBuffer) {
	    byte[] buf = mByteBuffer;
	    if (buf != null) {
		mByteBuffer = null;
		if (mConfig != null) {
		    mConfig.freeFullBBuffer(buf);
		}
	    }
	}
    }
427870
protected void localRelease()
    {
        super.localRelease();

        _state.clear();

        _text = null;
        _disabled = false;
        _value = null;
        _hasError = false;
    }
281681
public int freeMemory() {
        int size = 0;
        for (int m = 0; m < memory.length; m++) {
            size += memory[m].length;
            memory[m] = null;
        }
        memory = null;
        return size;
    }
14696
private function _memory()
    {
        if (CommonFunctions::executeProgram('pidin', 'info', $buf)
           && preg_match('/^.* FreeMem:(\S+)Mb\/(\S+)Mb/', $buf, $memm)) {
            $this->sys->setMemTotal(1024*1024*$memm[2]);
            $this->sys->setMemFree(1024*1024*$memm[1]);
            $this->sys->setMemUsed(1024*1024*($memm[2]-$memm[1]));
        }
    }
655597
public void free()
    {
        this.setCacheMinutes(0);    // Turn off the cache
        Object[] keys = m_htDBList.keySet().toArray();
        for (int i = 0; i < keys.length; i++)
        { 
            Object key = keys[i];
            PDatabase pDatabase = (PDatabase)m_htDBList.get(key);
            pDatabase.free();
        } 
        m_htDBList.clear();
        m_htDBList = 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());
    }
1152707
def reset(self):
        """"""
        self.data_stack = stack.Stack()
        self.return_stack = stack.Stack()
        self.instruction_pointer = 0
        return self