docs: @Override
      public void resumeConsumer(int suspendFlag)
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "resumeConsumer", this);
  
          // Use this flag to identify whether a new thread must be spun off to look for more
          // messages
          boolean spinOffNewThread = false;
          try
          {
              // Take the lock
              this.lock();
  
              if (_consumerSuspended)
              {
                  boolean setStillSuspended = false;
  
                  // If we're resuming due to the ConsumerSet being resumed then we need to
                  // re-check the set's state due to us not holding the set's activeMessageCount
                  // lock at this time (due to the hierarchy). And if we find that the set is
                  // actually suspended (due to someone else in the set getting in and adding
                  // another message then we just ignore this resume as there'll be another one
                  // along when the count drops back below the limit again.
                  if (suspendFlag == DispatchableConsumerPoint.SUSPEND_FLAG_SET_ACTIVE_MSGS)
                      setStillSuspended = _consumerKey.isConsumerSetSuspended();
  
                  if (!setStillSuspended)
                  {
                      // clear the bit provided in the _suspendFlags
                      _suspendFlags &= ~suspendFlag;
  
                      if (_suspendFlags == 0) // No flags set so resume the consumer
                      {
                          _consumerSuspended = false;
  
                          // If the consumer is still active (started) we need
                          // to kickstart the consumer back into life to check for more
                          // messages
                          if (!_stopped && !_closing)
                          {
                              if (_asynchConsumerRegistered)
                              {
                                  if (!_asynchConsumer.isAsynchConsumerRunning())
                                  {
                                      // We'll have to take the full lock hierarchy and
                                      // possibly spin off another thread to start looking for more messages
                                      // (just like start())
                                      spinOffNewThread = true;
                                  }
                              }
                              else
                              {
                                  // Wake up any synchronous receivers
                                  _waiter.signal();
                              }
                          }
                      }
                  }
              }
          } finally
          {
              this.unlock();
          }
  
          // start a new thread to run the callback if we determined that it was necessary   
          if (spinOffNewThread)
          {
              try
              {
                  _messageProcessor.startNewThread(new AsynchThread(this, false));
              } catch (InterruptedException e)
              {
                  FFDCFilter.processException(
                                              e,
                                              "com.ibm.ws.sib.processor.impl.JSLocalConsumerPoint.resumeConsumer",
                                              "1:4978:1.22.5.1",
                                              this);
  
                  SibTr.exception(tc, e);
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(tc, "resumeConsumer", e);
              }
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "resumeConsumer");
      }