code: private void eventPostCommitRemove(SIMPMessage message) throws SIResourceException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "eventPostCommitRemove", message);
  
          if (_consumerStoppable)
          {
              // Lock down the consumer as we need to count stuff...
  
              //  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 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
              {
                  this.lock();
                  try
                  {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                          SibTr.debug(tc, "Resetting sequential count to zero (from " + _sequentialMessageCounter + ")");
  
                      // Set the sequential failure counter back to zero as we've now seen a message succeed!
                      _sequentialMessageCounter = 0;
                  } finally
                  {
                      this.unlock();
                  }
              } finally
              {
                  if (cachedKeyGroup != null)
                      cachedKeyGroup.unlock();
              }
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "eventPostCommitRemove");
      }
docs: /*
  eventPostCommitRemove is called when a commit has occurred
  of a remove of a message by an async consumer. If the async consumer
  implements the StoppableAsynchConsumerCallback then this method will
  reset the current sequential failure count. The re-availability of this
  message will be handled by the consumer dispatcher callbacks.