docs: @Override
      public void alarm(Object arg0)
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "alarm", new Object[] { this });
  
          // Get the current time to use in expiry processing
          long currentTime = System.currentTimeMillis();
          long nextExpiry = 0;
          List<SIMPMessage> expiredHiddenMessages = null;
          boolean resumeConsumerAfterUnlock = false;
  
          // Lock down this consumer to prevent any other thread from modifying the hidden message list
          this.lock();
          try
          {
              boolean continueExpiryProcessing = true;
              while (continueExpiryProcessing)
              {
                  continueExpiryProcessing = false;
  
                  // We only have to do anything if we have hidden messages
                  if (!_hiddenMessages.isEmpty())
                  {
                      // Get the first hidden message from the list
                      SIMPMessage firstHiddenMessage = _hiddenMessages.get(0);
  
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                          SibTr.debug(tc, "Checking hidden message " + firstHiddenMessage.getMessage().getSystemMessageId() + " from list");
  
                      // See if the message has completed its delay
                      if (firstHiddenMessage.getHiddenExpiryTime() <= (currentTime + 10)) // Add 10 milliseconds just to make sure there's no rounding problems
                      {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              SibTr.debug(tc, "alarm", "Expiring hidden state on: " + firstHiddenMessage);
  
                          if (expiredHiddenMessages == null)
                              expiredHiddenMessages = new ArrayList<SIMPMessage>(1);
  
                          expiredHiddenMessages.add(firstHiddenMessage);
  
                          _hiddenMessages.remove(firstHiddenMessage);
  
                          continueExpiryProcessing = true;
                      }
                      // As these hidden messages have the same delay they're stored in the list in order. So as
                      // soon as we see one message that hasn't finished its hide period we can drop out.
                      else
                      {
                          nextExpiry = firstHiddenMessage.getHiddenExpiryTime() - currentTime;
                      }
                  } // !empty
              } // while
  
              // If we've suspended this consumer because we hid the maximum allowed number of messages and we're
              // about to unlock some we can resume it, but only after we've unlocked the messages, otherwise
              // they'll start processing older ones first.
              if (((_suspendFlags & SUSPEND_FLAG_MAX_HIDDEN_MSGS_REACHED) > 0) && (expiredHiddenMessages != null))
              {
                  resumeConsumerAfterUnlock = true;
              }
  
              // If there is a message to "reveal" in the future register an alarm for it (before
              // we unlock the other messages as that may take some time)
              if (nextExpiry > 0)
              {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(tc, "alarm", "Registering alarm for: " + nextExpiry);
  
                  _alarmManager.create(nextExpiry, this);
              }
              else
                  _hiddenMsgAlarmRegistered = false;
  
          } // try
          finally
          {
              this.unlock();
          }
  
          // If we found expired hidden messages, then mark then as unhidden and unlock it (outside
          // a lock
          if (expiredHiddenMessages != null)
          {
              for (int i = 0; i < expiredHiddenMessages.size(); i++)
              {
                  try
                  {
                      SIMPMessage hiddenMessage = expiredHiddenMessages.get(i);
  
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                          SibTr.debug(tc, "Unlocking hidden message: " + hiddenMessage.getMessage().getSystemMessageId());
  
                      hiddenMessage.markHiddenMessage(false);
                      hiddenMessage.unlockMsg(_consumerKey.getGetCursor(hiddenMessage).getLockID(), null, true);
                  } catch (MessageStoreException e)
                  {
                      // MessageStoreException shouldn't occur so FFDC.
                      FFDCFilter.processException(
                                                  e,
                                                  "com.ibm.ws.sib.processor.impl.JSLocalConsumerPoint.alarm",
                                                  "1:5951:1.22.5.1",
                                                  this);
  
                      SibTr.exception(tc, e);
                      SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
                                  new Object[] {
                                                "com.ibm.ws.sib.processor.impl.JSLocalConsumerPoint.alarm",
                                                "1:5958:1.22.5.1",
                                                e });
  
                      // Don't throw anything - continue on regardless so that all messages are processed
                  }
              } // for
          } // expired hidden messages found
  
          if (resumeConsumerAfterUnlock)
          {
              resumeConsumer(SUSPEND_FLAG_MAX_HIDDEN_MSGS_REACHED);
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "alarm", this);
      }