releases the given Particle

 @parama [Particle] p the Particle to be released

 @note the Particle is stored into Hash @pool to be reused as soon as needed

 @see Particle#reset! the Particle is reseted before beeing stored
771123
def release_p p
            # hope there is no circular loop
            while p2=p.merged_shift
                release_p p2
            end
            p.reset!
            ( @pool[p.class] ||= [] ) << p
        end
533151
public void release() 
    { 
        if (!_hasAcquired)
            return;

        // Deliver the onRelease event to the registered listeners
        for (ResourceEvents resourceListener : _listeners)
            resourceListener.onRelease();

        // Unregister this ResourceContext with associated container context
        _containerContext.removeResourceContext(this, _bean);

        // Reset the flag to indicate resources have been released.
        _hasAcquired = false;
    }
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;
		}

	}
351364
function(){
					hasher.stop();
					hasher.initialized.dispose();
					hasher.stopped.dispose();
					hasher.changed.dispose();
					_frame = hasher = window.hasher = null;
				}
418420
def __release_particle(self):
        """"""
        # Calculate a potential angle for the particle.
        angle = random.randint(int(self.direction_range[0]), int(self.direction_range[1]))
        velocity = Vector2.from_polar(angle, self.particle_speed)

        physics = PhysicsObj(self.coords, Vector2(), velocity)
        particle = self.particle_pool.request_object()
        particle.initalize(physics)
        self.particles.append(particle)
        self.current_particle_count += 1
1107909
@Override
    public void release(Pointer pointer, MemoryKind kind) {
        if (kind == MemoryKind.DEVICE) {
            NativeOpsHolder.getInstance().getDeviceNativeOps().freeDevice(pointer, 0);
            pointer.setNull();
        } else if (kind == MemoryKind.HOST) {
            NativeOpsHolder.getInstance().getDeviceNativeOps().freeHost(pointer);
            pointer.setNull();
        }
    }
809231
public void dispose ()
    {
        if (_buffer != null) {
            // if there are sources bound to this buffer, we must wait
            // for them to be unbound
            if (_bound > 0) {
                _state = UNLOADING;
                return;
            }

            // free up our buffer
            _buffer.delete();
            _buffer = null;
            _state = UNLOADED;
        }
    }
675706
function destroy() {
         me.pool.push(this.offset);
         this.offset = undefined;
         me.pool.push(this.ratio);
         this.ratio = undefined;

         this._super(me.Renderable, "destroy");
       }
913419
public void cleanup() {
        state = null;
        if (headerBuffer != null) {
            bufferPool.deallocate(headerBuffer);
        }
        if (dataBuffer != null) {
            bufferPool.deallocate(dataBuffer);
        }
    }
1061071
@Internal
    public void release() {
        Object body = getBody().orElse(null);
        releaseIfNecessary(body);
        for (ByteBufHolder byteBuf : receivedContent) {
            releaseIfNecessary(byteBuf);
        }
        for (ByteBufHolder byteBuf : receivedData.values()) {
            releaseIfNecessary(byteBuf);
        }
        if (this.body != null && this.body instanceof ReferenceCounted) {
            ReferenceCounted referenceCounted = (ReferenceCounted) this.body;
            releaseIfNecessary(referenceCounted);
        }
        for (Map.Entry<String, Object> attribute : attributes) {
            Object value = attribute.getValue();
            releaseIfNecessary(value);
        }
    }
948743
private void reset() {
		for (DietzfelbingerHash hashfunction : this.hashfunctions) {
			hashfunction.nextHashFunction();
		}

		int sizeTables = 1 << this.hashSize;
		for (List<Entry<T>> table : this.tables) {
			table.clear();
			for (int j = 0; j < sizeTables; j++) {
				table.add(null);
			}
		}

		this.stash.clear();
		this.stashSize = 0;

		for (Entry<T> entry : this.elements) {
			fileElement(entry, false);
		}
	}
821936
public void release(PooledWsByteBufferImpl buffer) {
        if (inUseTable != null) {
            inUseTable.remove(buffer);
        }
        boolean pooled = pool.put(buffer);
        if (isDirectPool && !pooled) {
            destroy(buffer);
        }
    }
1057839
def release(self, conn):
        
        self._in_use.remove(conn)
        if conn.reader.at_eof() or conn.reader.exception():
            self._do_close(conn)
        else:
            self._pool.put_nowait(conn)
452299
protected void release() {
        Log.d(TAG, "release");
        releaseObjects();

        if (this.mediaPlayer != null) {
            this.mediaPlayer.setOnBufferingUpdateListener(null);
            this.mediaPlayer.setOnPreparedListener(null);
            this.mediaPlayer.setOnErrorListener(null);
            this.mediaPlayer.setOnSeekCompleteListener(null);
            this.mediaPlayer.setOnCompletionListener(null);
            this.mediaPlayer.setOnInfoListener(null);
            this.mediaPlayer.setOnVideoSizeChangedListener(null);
            this.mediaPlayer.release();
            this.mediaPlayer = null;
        }

        this.currentState = State.END;
    }
1305021
protected void release() {
        if (!releaseNeeded.get()) {
            return; // there is no point in releasing if we do not wait. Avoid excessive releasing.
        }

        releaseNeeded.set(false);// release is under way
        backgroundExecutor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    List<Command> releaseCommandList = new ArrayList<Command>(Collections.singletonList(releaseCommand));
                    transmit(releaseCommandList);
                } catch (DolphinRemotingException e) {
                    handleError(e);
                }
            }
        });
    }
215350
function releaseObject(object) {
    object.criteria = object.value = null;
    if (objectPool.length < MAX_POOL_SIZE) {
      objectPool.push(object);
    }
  }
802051
function() {
        // Put all the particles back
        for (var i = 0; i < this._particles.length; i++) {
            var p = this._particles[i];
            p.emitter.kill(p);
        }
        this._particles.length = 0;
        this._elapsedTime = 0;
        this._emitting = true;
    }