Closes this proxy queue conversation group.
187169
public void close()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "close");
      synchronized(this)
      {
         if (closed)
         {
            idToProxyQueueMap.clear();
            factory.groupCloseNotification(conversation, this);
         } 
      }      
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "close");
   }
660828
def close(self):
        
        try:
            if self.consumer:
                self.requeue_messages(m for _, m in iter_queue(self.delay_queue))
                self.consumer.close()
        except ConnectionError:
            pass
563968
def close(self):
        
        if self._publish:
            self._events.put((self._listener.publish_server_closed,
                              (self._description.address, self._topology_id)))
        self._monitor.close()
        self._pool.reset()
106922
async def _close(self):
        

        # Remove the core NATS Streaming subscriptions.
        try:
            if self._hb_inbox_sid is not None:
                await self._nc.unsubscribe(self._hb_inbox_sid)
                self._hb_inbox = None
                self._hb_inbox_sid = None
            if self._ack_subject_sid is not None:
                await self._nc.unsubscribe(self._ack_subject_sid)
                self._ack_subject = None
                self._ack_subject_sid = None
        except:
            # FIXME: async error in case these fail?
            pass

        # Remove all the related subscriptions
        for _, sub in self._sub_map.items():
            if sub._msgs_task is not None:
                sub._msgs_task.cancel()
            try:
                await self._nc.unsubscribe(sub.sid)
            except:
                continue
        self._sub_map = {}
1370055
protected void close() {
        guard.close();

        if (fd != null) {
            datagramSocketClose();
            ResourceManager.afterUdpClose();
            fd = null;
        }
    }
807262
public void close()	{
		if (watchdog != null) {
			watchdog.cancel();
			watchdog = null;
		}
		
		disconnect();
		
		// clear nodes collection and send queue
		for (Object listener : this.zwaveEventListeners.toArray()) {
			if (!(listener instanceof ZWaveNode))
				continue;
			
			this.zwaveEventListeners.remove(listener);
		}
		
		this.zwaveNodes.clear();
		this.sendQueue.clear();
		
		logger.info("Stopped Z-Wave controller");
	}
900176
void close() {
    broadcastFuture.cancel(false);
    groupMembershipService.removeListener(groupMembershipEventListener);
    clusterMembershipService.removeListener(clusterMembershipEventListener);
  }
588588
@Override
	public void close()
    {
        closeTransport(false);
        
        // Wait for threads to complete
        try
		{
        	if (receiverThread != null && Thread.currentThread() != receiverThread)
        		receiverThread.join();
		}
		catch (InterruptedException e)
		{
			log.error("#"+id+" wait for receiver thread termination was interrupted.");
		}
		try
		{
        	if (senderThread != null && Thread.currentThread() != senderThread)
        		senderThread.join();
		}
		catch (InterruptedException e)
		{
			log.error("#"+id+" wait for sender thread termination was interrupted.");
		}
    }
1119960
def close(self):
        """"""
        for channel in self._listening_to:
            self.toredis.unsubscribe(channel)
        self.toredis.unsubscribe(self.group_pubsub)
670272
def close():
    
    while len(wt_group.Group._instances) > 0:
        wt_group.Group._instances.popitem()[1].close()
393742
@Override
	public void close() {
		try {
			callbackRegistry.acceptConnectionStateChange(BitfinexConnectionStateEnum.DISCONNECTION_INIT);
			logger.debug("close() called");
			if (heartbeatThread != null) {
				heartbeatThread.interrupt();
				heartbeatThread = null;
			}

			if (websocketEndpoint != null) {
				websocketEndpoint.close();
				websocketEndpoint = null;
			}
			connectionStateChange(BitfinexConnectionStateEnum.DISCONNECTION_SUCCESS);
		} catch (final Exception e) {
			connectionStateChange(BitfinexConnectionStateEnum.DISCONNECTION_FAILED);
			throw new BitfinexClientException(e);
		}
	}
255477
def close(self):
        
        if self._Q is not None:
            for T in self._T:
                self._Q.interrupt()
            for n, T in enumerate(self._T):
                _log.debug('Join Context worker %d', n)
                T.join()
            _log.debug('Joined Context workers')
            self._Q, self._T = None, None
        super(Context, self).close()
1289364
def close(self) -> None:
        
        def _shutdown() -> None:
            self.transport.close()
            self.shutdown_event.set()

        with self._shutdown_lock:
            if not self._shutdown:
                self._shutdown = True
                self.protocol.loop.call_soon_threadsafe(_shutdown)
982176
def close(self):
        
        self.sasl.mechanism.destroy()
        self.sasl_client.get_client().destroy()
        self._underlying_xio.destroy()
1176379
@Override
  public void close() throws Exception {

    if (this.lookupClient != null) {
      this.lookupClient.close();
    }

    if (this.registryClient != null) {
      this.registryClient.close();
    }

    if (this.transport != null) {
      this.transport.close();
    }
  }
1024393
@Beta(SinceVersion.V1_1_0)
    public void close() {
        httpClient.dispatcher().executorService().shutdown();
        httpClient.connectionPool().evictAll();
        synchronized (httpClient.connectionPool()) {
            httpClient.connectionPool().notifyAll();
        }
        synchronized (AsyncTimeout.class) {
            AsyncTimeout.class.notifyAll();
        }
    }
1004253
def close(self, **kwargs):
        
        self.scale_down(self.cluster.scheduler.workers)
        return self.cluster.close(**kwargs)