No objects, so just notify of close as soon as there is demand.
17429
@Override
    final void doRequest(SubscriptionImpl subscription, long unused) {
        if (requested() != 0) {
            // Already have demand so don't need to do anything.
            return;
        }
        setRequested(1);
        notifySubscriberOfCloseEvent(subscription, SUCCESSFUL_CLOSE);
    }
405961
public void onAbnormalClose(CloseInfo close) {
        if (LOG.isDebugEnabled())
            LOG.debug("onAbnormalClose({})", close);
        ConnectionState event = null;
        synchronized (this) {
            if (this.state == ConnectionState.CLOSED) {
                // already closed
                return;
            }

            if (this.state == ConnectionState.OPEN) {
                this.cleanClose = false;
            }

            this.state = ConnectionState.CLOSED;
            finalClose.compareAndSet(null, close);
            this.inputAvailable = false;
            this.outputAvailable = false;
            this.closeHandshakeSource = CloseHandshakeSource.ABNORMAL;
            event = this.state;
        }
        notifyStateListeners(event);
    }
823667
def do_close(self, reason):
        """"""
        if self.closed:
            return
        self.closed = True
        self.reason = reason
        self.incoming.close()
        self.responses.close()
        if not self._closing:
            self.client.channel_failed(self, Failure(reason))
251788
public void notifyShutdown() {
        if (m_shutdown.compareAndSet(false, true)) {
            for (KafkaExternalConsumerRunner consumer : m_consumers) {
                consumer.shutdown();
            }
            close();
        }
    }
257121
protected boolean prepareClose() {
        synchronized (lock) {
            final State state = this.state;
            if (state == State.OPEN) {
                this.state = State.CLOSING;
                lock.notifyAll();
                return true;
            }
        }
        return false;
    }
1249375
def maybe_call_closing_deferred(self):
        

        if self._closing_deferred:
            self._closing_deferred.callback(self)
            self._closing_deferred = None
        self._when_closed.fire(self)
268081
def _notifyDone(self):
        '''
        
        '''
        if self.notified:
            return

        self.doneevent.set()

        for buid in self.mybldgbuids:
            del self.allbldgbuids[buid]

        self.notified = True
1177362
void prepareShutdown() {
        int oldState, newState;
        do {
            oldState = state;
            if ((oldState & CLOSED) != 0) {
                return;
            }
            newState = oldState | CLOSED;
        } while (!stateUpdater.compareAndSet(this, oldState, newState));
        // If there no active requests notify listeners directly
        if (newState == CLOSED) {
            handleCompleted();
        }
    }
275775
function isSetClose (date) {
  date = this.toDate(date);
  if (!date) {
    return null;
  }
  var info = getDayInfo(this.dayInfo, date);
  return info && info.close || false;
}
214121
def notify_all(self):
        """"""
        self.condition.acquire()
        # python 3.x
        try:
            self.condition.notify_all()
        except:
            self.condition.notifyAll()
        self.condition.release()
652332
def close_fast(self):
        """"""
        close_command = StandardSend(self._address,
                                     COMMAND_LIGHT_OFF_FAST_0X14_0X00)
        self._send_method(close_command, self._closed_message_received)
1172790
def closed(self):
        """"""
        closed = self._closing or self._closed
        if not closed and self._reader and self._reader.at_eof():
            self._closing = closed = True
            self._loop.call_soon(self._do_close, None)
        return closed
1326034
def notify(self, *args, **kwargs):
        ''''''
        for handler in tuple(self.handlers):
            handler(*args, **kwargs)
321848
def _onLeave(self, evt):
        """"""

        evt.Skip()
        FigureCanvasBase.leave_notify_event(self, guiEvent = evt)
495183
def onClose(self, was_clean, code, reason):
        
        logger.debug("Connection closed ({peer})".format(peer=self.peer))

        # Publish ON_CLOSE message
        self.factory.mease.publisher.publish(
            message_type=ON_CLOSE, client_id=self._client_id, client_storage=self.storage)

        self.factory.remove_client(self)
873011
@Override
    public void alertISClose() {
        if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) {
            logger.logp(Level.FINE, CLASS_NAME,"alertISClose()", "");
        }
        if (WCCustomProperties.CHECK_REQUEST_OBJECT_IN_USE){
            checkRequestObjectInUse();
        }
        
        if (_srtRequestHelper != null)
            _srtRequestHelper._InputStreamClosed=true; 
    }
1354434
def _on_closed(self):
        """"""
        self._connected.clear()
        if not self._closing:
            if self._on_close_callback:
                self._on_close_callback()
            else:
                raise exceptions.ConnectionError('closed')