docs: @Override
      public boolean put(SIMPMessage msg, boolean isOnItemStream)
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "put", new Object[] { this, msg, Boolean.valueOf(isOnItemStream), this });
  
          //we will return this var to say if we have NOT taken the message
          boolean msgTaken = false;
          //indicates if we should try and deliver this message asychronously
          boolean deliverToAsynchCon = false;
          // And on the same thread or not
          boolean inLineAsynchCon = false;
  
          // We can't hold the LCP lock before we hold the keyGroup lock and we don't want to
          // take the asynch lock as we'll block on a consumerMessage call but the keyGroup
          // is set inside the LCP and asynch locks and could therefore vanish between checking for it
          // and trying to lock it here. So we take a dirty read of the keyGroup and if we
          // got it we'll lock it. This does mean there are slight windows around setting
          // and unsetting of the keyGroup but the worst case is that we lock the group when
          // we didn't need to (as we're no longer a member of the group).
          JSKeyGroup cachedKeyGroup = _keyGroup;
  
          // We're about to take the consumer's lock and we want to return as quickly as
          // possible because we're currently running on the producer's thread, so we set
          // the flag in the hope that anyone who had the lock will yield for us.
          _lockRequested = true;
  
          // We're a member of a group so we must lock it before we go for the LCP lock
          // and take the message
          if (cachedKeyGroup != null)
              cachedKeyGroup.lock();
  
          try
          {
              //Can't put more than one message at once so synchronize on this
              this.lock();
              try
              {
                  // We've got the lock now so unset the flag
                  _lockRequested = false;
  
                  // Try to take the message that we've been given
                  boolean msgLockingError = false;
                  try
                  {
                      msgTaken = takeMessage(msg, isOnItemStream);
                  } catch (SIResourceException e)
                  {
                      // No FFDC code needed
                      SibTr.exception(tc, e);
  
                      msgLockingError = true;
                  }
  
                  // Take a snapshot of the deliverToAsynchCon value before we release the lock
                  // (if the consumer is in an isolated run they will have been notified as if
                  // they were a synchronous consumer (inside takeMessage).
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(tc, "asynch consumer reg: " + Boolean.valueOf(_asynchConsumerRegistered)
                                      + ", isolatedRun: " + Boolean.valueOf(_isolatedRun));
  
                  if (msgTaken || msgLockingError)
                      deliverToAsynchCon = (_asynchConsumerRegistered && !_isolatedRun);
  
                  // Remember how they wish to be run
                  inLineAsynchCon = _inLine;
              } finally
              {
                  this.unlock();
              }
          } finally
          {
              if (cachedKeyGroup != null)
                  cachedKeyGroup.unlock();
          }
  
          // If we want to deliver the attached message to an Asynchronous Consumer
          // (Outside synchronization to avoid lock conflict)
          if (deliverToAsynchCon)
          {
              // If the consumer has said it want's inlining then we should call them
              // on this thread - lets hope it doesn't take too long.
              // We can't do this if the message is being made reavailable as the thread
              // that did this may already hold the LCP lock so it can't take the Asynch
              // lock as this would break the locking hierarchy.
              if (inLineAsynchCon && !msg.isReavailable())
              {
                  try
                  {
                      runAsynchConsumer(false);
                  } catch (Throwable e)
                  {
                      FFDCFilter.processException(
                                                  e,
                                                  "com.ibm.ws.sib.processor.impl.JSLocalConsumerPoint.put",
                                                  "1:817: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.
                          closeSession(e);
                      } catch (Exception ee)
                      {
                          // No FFDC code needed
                          SibTr.exception(tc, ee);
                      }
  
                      if (e instanceof ThreadDeath)
                      {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                              SibTr.exit(tc, "put", e);
                          throw (ThreadDeath) e;
                      }
  
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                          SibTr.exit(tc, "put", e);
                  }
              }
              else
              {
                  try
                  {
                      //start up a new thread (from the MP's thread pool)
                      //to deliver the message asynchronously
                      _messageProcessor.startNewThread(new AsynchThread(this, false));
                  } catch (InterruptedException e)
                  {
                      // No FFDC code needed
  
                      //Trace only, maybe we'll be able to deliver later?
                      SibTr.exception(tc, e);
                  }
              }
          }
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "put", Boolean.valueOf(msgTaken));
          //Does the consumer dispatcher have to pick another consumer?
          //return true if we have taken the message given to us
          return msgTaken;
      }