docs: public void commitAddActiveMessage()
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.entry(this, tc, "commitAddActiveMessage");
  
      // Lock the active message counter lock
      synchronized(maxActiveMessageLock)
      {
        // Move the prepared add to the real count
        currentActiveMessages++;
        preparedActiveMessages--;
        
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
          SibTr.debug(tc, "Active Messages: current: " + currentActiveMessages +
                            ", prepared: " + preparedActiveMessages +
                            ", maximum: " + maxActiveMessages +
                            " (suspended: " + consumerSetSuspended + ")");
        
        // We should never go negative, if we do something has gone wrong - FFDC
        if(preparedActiveMessages < 0)
        {
          SIErrorException e = new SIErrorException(
              nls.getFormattedMessage(
                "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                new Object[] {
                  "com.ibm.ws.sib.processor.impl.JSConsumerSet.commitAddActiveMessage",
                  "1:499:1.16",
                  Integer.valueOf(preparedActiveMessages),
                  Integer.valueOf(currentActiveMessages),
                  Integer.valueOf(maxActiveMessages),
                  Boolean.valueOf(consumerSetSuspended)
                  },
                null));
  
            FFDCFilter.processException(
              e,
              "com.ibm.ws.sib.processor.impl.JSConsumerSet.commitAddActiveMessage",
              "1:510:1.16",
              this);
  
            SibTr.exception(tc, e);
            SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001",
              new Object[] {
                "com.ibm.ws.sib.processor.impl.JSConsumerSet.commitAddActiveMessage",
                "1:517:1.16" });
        }
        
        // If we currently hold the write lock (as we will always either hold
        // the read lock of the write lock we know this check will return the right
        // answer (i.e. it can't change under us)) we must have thought this add
        // would take us up to the limit and therefore require a suspend.
        if(maxActiveMessagePrepareLock.isWriteLockedByCurrentThread())
        {
          // If the limit has been reached, suspend the set
          if(currentActiveMessages == maxActiveMessages)
          {
            // All this does is mark the set as suspended. We leave it up to the members
            // of the set to notice that the set is suspended and suspend themselves.
            // This is more efficient than going round and suspending everyone, only to
            // have to resume then all again in a second. Hopefully the set will be
            // resumed before most of them notice it was suspended.
            consumerSetSuspended = true;
  
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
              SibTr.debug(tc, "JSConsumerSet suspended " + this);
          }
          
          // Release the write lock
          maxActiveMessagePrepareWriteLock.unlock();
          
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            SibTr.debug(tc, "maxActiveMessagePrepareWriteLock.unlock(): " + maxActiveMessagePrepareLock);
        }
        else
        {
          // We only held a read lock, release it now
          maxActiveMessagePrepareReadLock.unlock();
          
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            SibTr.debug(tc, "maxActiveMessagePrepareReadLock.unlock(): " + maxActiveMessagePrepareLock);
        }
      }
  
      if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.exit(this, tc, "commitAddActiveMessage");
    }