Release action for shared mode -- signals successor and ensures
propagation. (Note: For exclusive mode, release just amounts
to calling unparkSuccessor of head if it needs signal.)
773301
private void doReleaseShared() {
        /*
         * Ensure that a release propagates, even if there are other
         * in-progress acquires/releases.  This proceeds in the usual
         * way of trying to unparkSuccessor of head if it needs
         * signal. But if it does not, status is set to PROPAGATE to
         * ensure that upon release, propagation continues.
         * Additionally, we must loop in case a new node is added
         * while we are doing this. Also, unlike other uses of
         * unparkSuccessor, we need to know if CAS to reset status
         * fails, if so rechecking.
         */
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    if (!h.compareAndSetWaitStatus(Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !h.compareAndSetWaitStatus(0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }
790360
def release(self, tid, fh):

        

        try:
            try:
                self.fds[fh].unregisterHandler(fh)

            except AttributeError:
                pass

            del self.fds[fh]

        except KeyError:
            raise FuseOSError(errno.EBADF)

        return 0
521663
public void release() {
	parent = null;
	id = null;
	if( values != null ) {
	    values.clear();
	}
	values = null;
    }
1254686
def release_client(self, cb):
        
        cb.stop_using()
        self._q.put(cb, True)
544687
def release
      @refresh_mutex.synchronize {
        @unlock = true

        delete

        @refresh_signal.signal
      }


      @refresh_thread.join if @refresh_thread
      @event_manager.create_event(
        {
          user: Config.current_job.username,
          action: 'release',
          object_type: 'lock',
          object_name: @name,
          task: @task_id,
          deployment: @deployment_name,
        }
      )
    end
924262
public void release() 
    {
    	IPhynixxManagedConnection<C> con= this.connection;
        if (connection != null) {
            this.connection.removeConnectionListener(this);
        }
        this.connection = null;
        
        // return con; 
    }
281692
def release(self, key, owner):
        
        status = self.collection.find_and_modify(
            {'_id': key, 'owner': owner},
            {'locked': False, 'owner': None, 'created': None, 'expire': None}
        )
896604
@Override
	public CompletableFuture<?> releaseSlot(@Nullable Throwable cause) {
		if (!isCanceled()) {
			final CompletableFuture<?> terminationFuture;

			if (payload != null) {
				// trigger the failure of the slot payload
				payload.fail(cause != null ? cause : new FlinkException("TaskManager was lost/killed: " + getTaskManagerLocation()));

				// wait for the termination of the payload before releasing the slot
				terminationFuture = payload.getTerminalStateFuture();
			} else {
				terminationFuture = CompletableFuture.completedFuture(null);
			}

			terminationFuture.whenComplete(
				(Object ignored, Throwable throwable) -> {
					// release directly (if we are directly allocated),
					// otherwise release through the parent shared slot
					if (getParent() == null) {
						// we have to give back the slot to the owning instance
						if (markCancelled()) {
							try {
								getOwner().returnLogicalSlot(this);
								releaseFuture.complete(null);
							} catch (Exception e) {
								releaseFuture.completeExceptionally(e);
							}
						}
					} else {
						// we have to ask our parent to dispose us
						getParent().releaseChild(this);

						releaseFuture.complete(null);
					}
				});
		}

		return releaseFuture;
	}
1211121
void releaseSharedSlot(SharedSlot sharedSlot) {
		synchronized (lock) {
			if (sharedSlot.markCancelled()) {
				// we are releasing this slot
				
				if (sharedSlot.hasChildren()) {
					final FlinkException cause = new FlinkException("Releasing shared slot parent.");
					// by simply releasing all children, we should eventually release this slot.
					Set<Slot> children = sharedSlot.getSubSlots();
					while (children.size() > 0) {
						children.iterator().next().releaseSlot(cause);
					}
				}
				else {
					// if there are no children that trigger the release, we trigger it directly
					internalDisposeEmptySharedSlot(sharedSlot);
				}
			}
		}
	}
886568
public function release()
    {
        if ($this->handle) {
            flock($this->handle, LOCK_UN | LOCK_NB);
            fclose($this->handle);
            $this->handle = null;
        }
    }
271884
def release(self):
        
        if self.is_locked:
            os.close(self.fd)
            os.unlink(self.lockfile)
            self.is_locked = False
295819
public void release() {
        getGVRContext().getApplication().getEventReceiver().removeListener(mActivityEventsListener);
        if (mVideo == null) {
            return;
        }

        mVideo.release();
    }
1228335
protected void release()
   {
      if (tc.isEntryEnabled()) SibTr.entry(this, tc, "release");
      if (!transmissionsRemaining)
      {
         if (tc.isDebugEnabled()) SibTr.debug(this, tc, "no more transmissions remaining - repooling");
         
         // Ensure we release the byte buffers back into the pool
         if (buffer != null)
         {
            buffer.release();
         }
         
         connection = null;
         conversation = null;
         buffer = null;
         sendListener = null;
         pool.add(this);
      }
      if (tc.isEntryEnabled()) SibTr.exit(this, tc, "release");
   }
786258
void leaveSafeMode(boolean checkForUpgrades) throws SafeModeException {
    writeLock();
    try {
      if (!isInSafeMode()) {
        NameNode.stateChangeLog.info("STATE* Safe mode is already OFF.");
        return;
      }
      if (getDistributedUpgradeState()) {
        throw new SafeModeException("Distributed upgrade is in progress",
          safeMode);
      }
      safeMode.leave(checkForUpgrades);
      safeMode = null;
    } finally {
      writeUnlock();
    }
  }
708159
function ActionEase (opts) {
    if (!opts.action) {
        throw "Ease: action argument must be non-nil"
    }
    ActionEase.superclass.constructor.call(this, {duration: opts.action.duration})

    this.other = opts.action
}
370688
public void releasePermits(long number, Result result, long startNanos) {
        releasePermits(number, result, startNanos, clock.nanoTime());
    }
1288579
def release(self,
                job: Job,
                priority: int = DEFAULT_PRIORITY,
                delay: int = DEFAULT_DELAY) -> None:
        
        self._send_cmd(b'release %d %d %d' % (job.id, priority, delay), b'RELEASED')