code: private boolean prepareAddActiveMessage()
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(this, tc, "prepareAddActiveMessage");
  
          boolean messageAccepted = true;
  
          // We can't even accept the next message if the consumer is already
          // suspended
          if (_consumerSuspended)
              messageAccepted = false;
          else
          {
              // If we're a member of a ConsumerSet then add this message to the
              // set's quota - if there's space (returning 'false' indicates that
              // the set is already full without this message)
              if (!_consumerKey.prepareAddActiveMessage())
              {
                  messageAccepted = false;
                  suspendConsumer(DispatchableConsumerPoint.SUSPEND_FLAG_SET_ACTIVE_MSGS);
              }
          }
  
          // We can defer any local maxActiveMessage changes until the commit as there's
          // no chance of another thread getting for this consumer getting in before then
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(this, tc,
                         "prepareAddActiveMessage",
                         new Object[] { Boolean.valueOf(messageAccepted) });
  
          return messageAccepted;
      }
docs: Prepare to add an active message to the counter(s) if there is space.
  
  False is returned when there is no room for this message.
  
  If we're counting active messages on this consumer (maxActiveMessages > 0)
  then we don't need to do any prepare-time work, instead we just check that
  we have space, i.e. we're not already suspended.
  
  If we're in a ConsumerSet we must 'reserve' our active message now, before
  we actually have it in our hands, to make sure multiple members of the set
  don't concurrently add lots of messages, thus exceeding the concurrency limit
  on the set.
  
  This prepare is either committed in the case where the caller goes on to
  successfully lock a message, or rolledback where they fail (e.g. no message
  is available)
  
  NOTE: Callers to this method will have the JSLocalConsumerPoint locked