docs: public void start(int requestNumber, boolean deliverImmediately, boolean sendReply, SendListener sendListener, boolean restart) //471642
     {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "start",
                                             new Object[]{requestNumber,
                                                          deliverImmediately,
                                                          sendReply,
                                                          sendListener,
                                                          restart                                                 //471642
                                                          });
  
        if (restart && stoppableSessionStopped) {                                                                 //471642
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Stoppable session now stopped so ignoring the restart request");
        } else {                                                                                                  //471642
          stoppableSessionStopped = false;                                                                        //471642
  
          // We need to lock this down with a mutex lock here as it is possible that we could call
          // start on the sub consumer (or super class) causing the client to get notified that we
          // have started. If the client then decides to perform another operation which requires
          // checking if the session is started (say by calling isStarted()) we still may not have set
          // the started flag to true by the time they call this - causing really weird results (see
          // defect 347591).
          // As such, we lock around the start call by waiting on the semaphore before entering the
          // critical region. We then send the start and the SessionStartSendListener() will post the
          // semaphore when the data is actually sent. The started flag is updated just before the
          // semaphore is posted.
  
          checkNotBrowserSession();
          
          SessionStartSendListener listener = new SessionStartSendListener();
          startSemaphore.waitOnIgnoringInterruptions();
  
          try {
              if (subConsumer != null) 
              {
                 subConsumer.start(requestNumber, deliverImmediately, sendReply, listener);
              } 
              else 
              {
                 super.start(requestNumber, deliverImmediately, sendReply, listener);
              }
           } 
          catch (RuntimeException e) {
              FFDCFilter.processException(e, CLASS_NAME + ".start",
                                          CommsConstants.CATMAINCONSUMER_START_01, this,
                                          new Object[]{subConsumer});
              
             // the listener may never post because of this, so we post now
             // to ensure the semaphore is not left dangling
             listener.errorOccurred(e);
             if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "start", e); 
             throw e;
           }
        }
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "start");
     }