docs: void start() throws JMSException {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(this, tc, "start");
  
          synchronized (stateLock) {
  
              // We will start each consumer inside its own catch block so that
              // the failing of a single consumer does not adversely affect any
              // other. The first exception that is received is stored in this
              // variable and will be passed back up to the Connection when all
              // the starts are complete.
              JMSException excReceived = null;
  
              // Start all the synchronous consumers
  
              // Take a copy of the list of synchronous consumers. A sync block in
              // createConsumer means that you cannot add anything to this list until
              // session.start completes, however consumers can still be removed (as
              // a result of the consumer.close operation), so by the time we get to
              // calling start on the elements in this list, some of them may already
              // be closed (pathalogical scenario). Calling start on a closed consumer
              // has no effect, so this shouldn't cause a problem.
              Object[] syncList = syncConsumers.toArray();
  
              for (int i = 0; i < syncList.length; i++) {
                  try {
                      ((JmsMsgConsumerImpl) syncList[i]).start();
                  } catch (JMSException e) {
                      // No FFDC code needed
                      // Cache the exception to be thrown back at the end of the method,
                      // but don't take any other action here. The exception will already
                      // have been logged in JmsMsgConsumerImpl.start.
                      if (excReceived == null) {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              SibTr.debug(this, tc, "JMSException received at Session.start. Will continue trying to start the remaining consumers.");
                          // Cache this exception for later use.
                          excReceived = e;
                      }
                  }
              }
  
              // Start all the asynchronous consumers.
              Iterator asyncList = asyncConsumers.iterator();
              while (asyncList.hasNext()) {
                  try {
                      ((JmsMsgConsumerImpl) asyncList.next()).start();
                  } catch (JMSException e) {
                      // No FFDC code needed
  
                      // Cache the exception to be thrown back at the end of the method,
                      // but don't take any other action here. The exception will already
                      // have been logged in JmsMsgConsumerImpl.start.
                      if (excReceived == null) {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              SibTr.debug(this, tc, "JMSException received at Session.start. Will continue trying to start the remaining asynch consumers.");
                          // Cache this exception for later use.
                          excReceived = e;
                      }
                  }
              }
  
              // Check whether an exception was thrown at any point during this method.
              if (excReceived != null) {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(this, tc, "An exception was received during Session.start. Propogate to Connection.");
                  throw excReceived;
              }
  
              // Flag that we have started everything.
              setState(STARTED);
  
          } // Release the lock
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(this, tc, "start");
      }