docs: void runAsynchConsumer(boolean isolatedRun) throws SIResourceException, SISessionDroppedException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "runAsynchConsumer", new Object[] { this, Boolean.valueOf(isolatedRun) });
  
          JSLocalConsumerPoint nextConsumer = this;
          boolean firstTimeRound = true;
  
          // We continue processing messages until we're told not to (we, or a
          // member of our group stops) or we run out of messages on our queue.
          // Each time round we drop the async lock
          do // while(nextConsumer != null)
          {
              // If we've been asked to yield, we yield
              if (_interruptConsumer)
              {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(tc, "External yield requested");
  
                  Thread.yield();
  
                  // We would expect to be stopped by the interrupting thread
                  if (!_stopped)
                  {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                          SibTr.debug(tc, "Yield appears to have been ignored");
                  }
              }
  
              synchronized (_asynchConsumerBusyLock)
              {
                  // Another runAsynchConsumer thread could get kicked off in parallel due to a suspended
                  // active-message consumer being resumed or maybe a message being attached by
                  // the ConsumerDispatcher.
                  // As we release and re-take the asynch lock each time round we need to keep
                  // a track of who was here first and let them continue, killing off any threads
                  // that come in halfway through.
                  if (!_runningAsynchConsumer || (!firstTimeRound && _runningAsynchConsumer))
                  {
                      // check to see if we still want to do this, if we dropped the lock it's possible
                      // someone else came in and stopped/closed us. In which case, they'll still be waiting
                      // for us to come back to them to say we've finished. So we need to notify them
                      // on our way out
                      if ((_stopped && !(isolatedRun))
                          || (!_stopped && isolatedRun) // We have to be stopped while in an isolated run
                          || _closed
                          || !_asynchConsumerRegistered)
                      {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              SibTr.debug(tc, "We've been interferred with: " + _stopped + ", " + _closed + ", " + _asynchConsumerRegistered);
  
                          // Obviously not, so bomb out...
                          nextConsumer = null;
                          _runningAsynchConsumer = false;
                      }
                      else
                      {
                          if (firstTimeRound)
                          {
                              firstTimeRound = false;
  
                              //process any messages which are already attached to this LCP
                              boolean msgDelivered = processAttachedMsgs();
  
                              //Process any msgs that built up while we were busy
                              //but not if this was an isolatedRun and we already delivered a message
                              if (!(msgDelivered && isolatedRun))
                              {
                                  nextConsumer = processQueuedMsgs(isolatedRun);
                              }
                          }
  
                          if (!isolatedRun && (nextConsumer != null))
                          {
                              // Every time we transfer a message to a different member of the keyGroup
                              // (the last message matched someone else's selector) we have to re-run
                              // processQueuedmsgs() to make sure nothing is left on the queue after
                              // processing
                              nextConsumer = nextConsumer.processQueuedMsgs(isolatedRun);
                          }
  
                          // Indicate that this consumer is about to go round again 
                          if (nextConsumer != null)
                              _runningAsynchConsumer = true;
                          else
                              _runningAsynchConsumer = false;
                      }
  
                      // If we're on our way out and we were interupted by another thread then we need
                      // to wake them up on our way out as they may be waiting for us to finish.
                      if (!_runningAsynchConsumer && _runAsynchConsumerInterupted)
                      {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              SibTr.debug(tc, "We've been told to stop, wake up whoever asked us");
                          _runAsynchConsumerInterupted = false;
                          _asynchConsumerBusyLock.notifyAll();
                      }
                  }
                  else
                      nextConsumer = null;
              } // synchronized
          } while (nextConsumer != null);
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "runAsynchConsumer");
      }