docs: @Override
      public void removeActiveMessages(int messages)
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(this, tc, "removeActiveMessages", new Object[] { Integer.valueOf(messages),
                                                                          Integer.valueOf(_currentActiveMessages),
                                                                          Integer.valueOf(_maxActiveMessages),
                                                                          Boolean.valueOf(_consumerSuspended),
                                                                          Boolean.valueOf(_bifurcatable) });
  
          // First we decrement the message count for any ConsumerSet we happen to be
          // a part of. If this happens to take us below the max for the set then we
          // will resume any consumers in the set (where appropriate). We then
          // handle any resuming of this consumer in this method (as it has to take
          // account of any maxActiveMessage setting for this consumer.
          _consumerKey.removeActiveMessages(messages);
  
          // Need to check maxActiveMessages for this consumer
          if (_bifurcatable && (_maxActiveMessages != 0))
          {
              boolean threasholdCrossed = false;
  
              // Lock the active message counter
              synchronized (_maxActiveMessageLock)
              {
                  _currentActiveMessages -= messages;
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(tc, "_currentActiveMessages: " + _currentActiveMessages);
  
                  // See if we've gone below the active limit we therefore need to
                  // resume the consumer (resumeConsumer() checks that the set is also
                  // resumed)
                  if ((_currentActiveMessages == (_maxActiveMessages - messages)))
                  {
                      // Remember to resume the consumer once we've released the maxActiveMessage
                      // lock
                      threasholdCrossed = true;
                  }
  
                  // We should never go negative, if we do something has gone wrong - FFDC
                  if (_currentActiveMessages < 0)
                  {
                      SIErrorException e = new SIErrorException(
                                      nls.getFormattedMessage(
                                                              "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                                                              new Object[] {
                                                                            "com.ibm.ws.sib.processor.impl.JSLocalConsumerPoint.removeActiveMessages",
                                                                            "1:4657:1.22.5.1",
                                                                            Integer.valueOf(_currentActiveMessages) },
                                                              null));
  
                      FFDCFilter.processException(
                                                  e,
                                                  "com.ibm.ws.sib.processor.impl.JSLocalConsumerPoint.removeActiveMessages",
                                                  "1:4664:1.22.5.1",
                                                  this);
  
                      SibTr.exception(tc, e);
                      SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                                  new Object[] {
                                                "com.ibm.ws.sib.processor.impl.JSLocalConsumerPoint.removeActiveMessages",
                                                "1:4671:1.22.5.1" });
                  }
              } // synchronized
  
              // The threashold was crossed, first take the LCP lock then the maxActiveMessage
              // lock again and re-check the current state before resuming the consumer.
              if (threasholdCrossed)
              {
                  this.lock();
                  try
                  {
                      synchronized (_maxActiveMessageLock)
                      {
                          // Re-check to make sure someone else hasn't got in between the
                          // above release of the maxActiveMessage lock and this point and
                          // added more active messages - suspending us again.
                          // The count could be less than the threashold because someone else
                          // also released a message - in this case we still need to be the
                          // one to resume the consumer as the other release wouldn't have crossed
                          // the threashold and therefore not be in this bit of code.
                          if (_currentActiveMessages < _maxActiveMessages)
                          {
                              resumeConsumer(SUSPEND_FLAG_ACTIVE_MSGS);
  
                              // (F001731)
                              // If we have an alarm registered to warn of long pauses then cancel it now
                              // (this will issue an all-clear message is the pause has already been reported)
                              if (_activeMsgBlockAlarm != null)
                                  _activeMsgBlockAlarm.cancelAlarm();
                          }
                      }
                  } finally
                  {
                      this.unlock();
                  }
              }
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(this, tc, "removeActiveMessages");
      }