Release the slot occupied by this assignment.
547020
public void unassignBySlot(WorkerSlot slot) {
        List<ExecutorDetails> executors = new ArrayList<>();
        for (ExecutorDetails executor : this.executorToSlot.keySet()) {
            WorkerSlot ws = this.executorToSlot.get(executor);
            if (ws.equals(slot)) {
                executors.add(executor);
            }
        }

        // remove
        for (ExecutorDetails executor : executors) {
            this.executorToSlot.remove(executor);
        }
    }
596503
private void releaseAssignedResource(@Nullable Throwable cause) {

		assertRunningInJobMasterMainThread();

		final LogicalSlot slot = assignedResource;

		if (slot != null) {
			ComponentMainThreadExecutor jobMasterMainThreadExecutor =
				getVertex().getExecutionGraph().getJobMasterMainThreadExecutor();

			slot.releaseSlot(cause)
				.whenComplete((Object ignored, Throwable throwable) -> {
					jobMasterMainThreadExecutor.assertRunningInMainThread();
					if (throwable != null) {
						releaseFuture.completeExceptionally(throwable);
					} else {
						releaseFuture.complete(null);
					}
				});
		} else {
			// no assigned resource --> we can directly complete the release future
			releaseFuture.complete(null);
		}
	}
245582
def release(self) -> None:
        """"""
        self._value += 1
        while self._waiters:
            waiter = self._waiters.popleft()
            if not waiter.done():
                self._value -= 1

                # If the waiter is a coroutine paused at
                #
                #     with (yield semaphore.acquire()):
                #
                # then the context manager's __exit__ calls release() at the end
                # of the "with" block.
                waiter.set_result(_ReleasingContextManager(self))
                break
1362337
public void release() {

        this.parent = null;

        this.id = null;
        this.facesJspId = null;
        this.created = false;
        this.bodyContent = null;
        this.isNestedInIterator = false;
        _nextChildIndex = 0;
    }
840236
def release(self):
		
		if self._locked is True:
			self._locked = False
			self._lock.release()
1075263
public final void release() {
		synchronized (this.LOCK) {
			if ((this.owner != null)
					&& (this.owner.get() == Thread.currentThread())) {
				this.acquire--;

				if (this.acquire == 0) {
					this.owner = null;
					this.LOCK.notify();
				}

				return;
			}

			if ((this.owner != null) && (this.owner.get() == null)) {
				this.owner = null;
				this.acquire = 0;
				this.LOCK.notify();
			}

			throw new IllegalMonitorStateException(Thread.currentThread()
					.getName()
					+ " is not the owner of the lock. "
					+ ((this.owner != null) ? ((Thread) this.owner.get())
							.getName() : "nobody") + " is the owner.");
		}
	}
933094
public void release() {
        if (released.compareAndSet(false, true)) {
            synchronized (releasingLock) {
                if (released.get()) {
                    impl.release(Integer.MAX_VALUE);
                }
            }
        }
    }
645290
private final boolean removeSlot(final int slot) {
		if (slot < 0) {
			log.error("faking slot=" + slot + " allocated=" + allocated);
			return false;
		}
		if (slot < allocated) {
			moveElementsLeft(keys, slot);
		}
		if (allocated > 0) {
			allocated--;
		}
		if (log.isDebugEnabled()) {
			log.debug("erased up key=" + keys[allocated]);
		}
		keys[allocated] = NULL_VALUE;
		return true;
	}
121030
public void remove() {
    for (int i = 0; i < buf.length; i++) {
      buf[i] = null;// force null for easier garbage
    }
    buf = null;
  }
575139
private void deallocate(HashtableEntry entry)
                    throws IOException,
                    EOFException,
                    FileManagerException,
                    ClassNotFoundException,
                    HashtableOnDiskException {
        if (entry.location == 0) {
            throw (new HashtableOnDiskException("deallocate:  space not allocated."));
        }

        filemgr.deallocate(entry.location);
        entry.location = 0;
    }
484125
public function stop()
    {
        if (!$this->openSlots) {
            throw new \LogicException('No slot started.');
        }

        $name = array_pop($this->openSlots);

        $this->slots[$name] = ob_get_clean();
    }
1265680
def copy(self):
        """"""
        missing = object()
        result = object.__new__(self.__class__)
        for name in self.__slots__:
            val = getattr(self, name, missing)
            if val is not missing:
                setattr(result, name, val)
        return result
443067
def release(self, conn):
        """"""
        self._pool_lock.acquire()
        self._pool.put(ConnectionWrapper(self._pool, conn))
        self._current_acquired -= 1
        self._pool_lock.release()
1069121
public void free(IPooledObject<V> borrowedObject, boolean reusable) {
		if (borrowedObject == null) return;

		if (borrowed.remove(borrowedObject))
		{
			((PoolableObject<V>)borrowedObject).releaseOwner();
			if (reusable)
				available.addFirst((PoolableObject<V>)borrowedObject);
		}
	}
1244225
def deallocate(self, batch):
        """"""
        self._incomplete.remove(batch)
        self._free.deallocate(batch.buffer())
413625
def deallocate(self):
        """"""
        if self._domain is not None:
            domain_delete(self._domain, self.logger)
        if self._network is not None:
            self._network_delete()
        if self._storage_pool is not None:
            self._storage_pool_delete()
        if self._hypervisor is not None:
            self._hypervisor_delete()
307010
def pop(self, settings):
        
        if settings:
            for name in self.__slots__:
                self._set(name, settings.pop(name, UNSET))