docs: @Override
      public void detachConsumerPoint(ConsumerKey consumerKey) throws SIResourceException, SINotPossibleInCurrentConfigurationException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "detachConsumerPoint", consumerKey);
  
          //  if p2p then we must remove the CP from the matchspace also
          if (!_isPubSub)
          {
              // Remove the CP from the MatchSpace
              _baseDestHandler.removeConsumerPointMatchTarget((DispatchableKey) consumerKey);
          }
          else
          {
              state = SIMPState.DELETED;
          }
  
          /*
           * 455255
           * A deadlock occurs between the close of consumers on asynch deletion of a destination
           * and the manual close of the consumer by the appliation. The two locks involved are t
           * the consumerPoints lock (below) and a lock on the _pseudoDurableAIHMap object in the
           * RemotePubSubSupport class.
           * To avoid this, we force a lock to be taken on the RemotePubSubSupport object before
           * either of the above locks is obtained. (In the ptop case we just take the lock on consumerPoints
           * twice)
           * The corresponding lock is found on RemotePubSubSupport.cleanupLocalisations()
           */
          final Object deletionLock;
          if (isPubSub())
              deletionLock = _baseDestHandler.getPubSubRealization().getRemotePubSubSupport();
          else
              deletionLock = consumerPoints;
  
          synchronized (deletionLock)
          {
              synchronized (consumerPoints)
              {
                  //remove this consumer point from the list of attached consumer points
                  //Note it may not be in the list if the detach is being forced by delete
                  //of the destination
                  if (consumerPoints.contains(consumerKey))
                  {
                      consumerPoints.remove(consumerKey);
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                          SibTr.debug(tc, "Consumer key removed - new size of consumerPoints is " + consumerPoints.size());
                  }
                  else
                  {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                          SibTr.debug(tc, "Consumer key not in map", consumerKey);
                  }
  
                  //166829.1
                  //If We are a subscription and non-durable, and we have no consumer attached,
                  //then delete this consumer dispatcher.  Note: the one case where we DO delete,
                  //even if we're durable, is when we're the RME for a remote durable subscription.
                  //However, when we're the RME, we don't have a matchspace entry.
                  if (consumerPoints.isEmpty()
                      && _isPubSub &&
                      dispatcherState.getSubscriberID().contains("_NON_DURABLE_NON_SHARED") //only non durable non shared consumers 
                      && (!isDurable() || (this instanceof RemoteConsumerDispatcher)))
                  {
                      // The proxy event message needs to be send and the call needs
                      // to be made to the proxy code.
                      // We know that it was also added to the MatchSpace.
                      deleteConsumerDispatcher(!isDurable());
                  }
              }
          }
  
          // Dealing pubsub non-durable shared consumers separately to avoid dead lock
          if (_isPubSub && (!isDurable()) && !dispatcherState.getSubscriberID().contains("_NON_DURABLE_NON_SHARED")) {
              // We have to deal pubsub non-durable shared consumers as separate as there is
              // chance of dead lock. The creatiing/obtaining CD for a cosnumer and attaching involves
              // getting locks on hashmap _destinationManager.getNondurableSharedSubscriptions() and
              // 'ConsumerPoints'
              //The above code locks ConsumerPoints first.. then after tries to lock 
              //_destinationManager.getNondurableSharedSubscriptions(), chance of deadlock
  
              // no deletionLock is required as no remote support is there.
  
              synchronized (_baseDestHandler.getDestinationManager().getNondurableSharedSubscriptions()) { // the lock is too harsh as it is entire ME wide
                  synchronized (consumerPoints) {
                      if (consumerPoints.isEmpty()) {
                          //no consumers attached then delete CD. It can be assured that no other consumer 
                          // would be trying obtain the CD
                          deleteConsumerDispatcher(!isDurable());
                      }
                  }
  
              }
  
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "detachConsumerPoint");
      }