docs: @Override
      public void runIsolatedAsynch(boolean deliverImmediately) throws SIIncorrectCallException, SISessionUnavailableException, SIResourceException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "runIsolatedAsynch", new Object[] { this, Boolean.valueOf(deliverImmediately) });
  
          synchronized (_asynchConsumerBusyLock)
          {
              // Lock the consumer session while we check that it is in a valid
              // state
              this.lock();
              try
              {
                  // Only valid if the consumer session is still open
                  checkNotClosed();
  
                  //if there is no callback registered, throw an exception
                  if (!_asynchConsumerRegistered)
                  {
                      SIIncorrectCallException e =
                                      new SIIncorrectCallException(
                                                      nls.getFormattedMessage(
                                                                              "ASYNCH_CONSUMER_ERROR_CWSIP0175",
                                                                              new Object[] { _consumerDispatcher.getDestination().getName(),
                                                                                            _messageProcessor.getMessagingEngineName() },
                                                                              null));
  
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                          SibTr.exit(tc, "runIsolatedAsynch", e);
  
                      throw e;
                  }
                  // we can't do an isolated run if the LCP is not in a stopped state
                  // so throw an exception
                  if (!_stopped)
                  {
                      SIIncorrectCallException e =
                                      new SIIncorrectCallException(
                                                      nls.getFormattedMessage(
                                                                              "ASYNCH_CONSUMER_RUN_ERROR_CWSIP0176",
                                                                              new Object[] { _consumerDispatcher.getDestination().getName(),
                                                                                            _consumerDispatcher.getMessageProcessor().getMessagingEngineName() },
                                                                              null));
  
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                          SibTr.exit(tc, "runIsolatedAsynch", e);
                      throw e;
                  }
  
                  // If the consumer has been stopped because the destination is not
                  // allowing consumers to get messages then we simply return.
                  if (_stoppedForReceiveAllowed)
                  {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                          SibTr.exit(tc, "runIsolatedAsynch", "Receive not allowed");
  
                      return;
                  }
              } // synchronized (this)
              finally
              {
                  this.unlock();
              }
          } // synchronized (asynchConsumer)
  
          //if we get this far then if deliverImmediately is set then this
          //implies that the callback should be inline
          if (deliverImmediately)
          {
              //run the asynch inline
              try
              {
                  runAsynchConsumer(true);
              } catch (Throwable e)
              {
                  FFDCFilter.processException(
                                              e,
                                              "com.ibm.ws.sib.processor.impl.JSLocalConsumerPoint.runIsolatedAsynch",
                                              "1:3182:1.22.5.1",
                                              this);
  
                  SibTr.exception(tc, e);
  
                  try
                  {
                      // Since the asynchConsumer has experienced an error of some kind, the best form
                      // of cleanup is to close down the session. This ensures any listeners get notified
                      // and can retry at some point later.
                      _consumerSession.close();
                      // don't notify asynchconsumer as we are been called inline
                  } catch (Exception ee)
                  {
                      // No FFDC code needed
                      SibTr.exception(tc, ee);
                  }
  
                  if (e instanceof ThreadDeath)
                  {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                          SibTr.exit(tc, "runIsolatedAsynch", e);
                      throw (ThreadDeath) e;
                  }
  
                  SISessionDroppedException sessionDroppedException = new SISessionDroppedException(
                                  nls.getFormattedMessage("CONSUMER_CLOSED_ERROR_CWSIP0177"
                                                          , new Object[] { _consumerDispatcher.getDestination().getName(),
                                                                          _messageProcessor.getMessagingEngineName() }
                                                          , null), e);
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(tc, "runIsolatedAsynch", sessionDroppedException);
  
                  //inline call so throwing exception rather than notifying
                  throw sessionDroppedException;
              }
          }
          else
          {
              //start up a new thread (from the MP's thread pool)
              //to deliver the message asynchronously
              try
              {
                  _messageProcessor.startNewThread(new AsynchThread(this, true));
              } catch (InterruptedException e)
              {
                  // No FFDC code needed
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(tc, "runIsolatedAsynch", e);
              }
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "runIsolatedAsynch");
      }