docs: protected ISession createISession(String id, int sessionVersion, boolean reuseTheId) {
          if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
              LoggingUtil.SESSION_LOGGER_CORE.entering(methodClassName, methodNames[CREATE_ISESSION], "id= " + id);
          }
          ISession iSession = null;
          boolean created = true; // set to false if we find another thread just
                                  // created this session
  
          // uses the same id to create if current id exists and isIdReuse is
          // specified or RRD request
          if ((null==id) || (!reuseTheId && !_store.idExists(id)) || (reuseTheId && id.equals(overflowId))){
              // creating a session with a new id
              while (iSession == null) {
                  id = _idGenerator.getID();
                  iSession = _store.createSession(id, true);
              }
          } else { // reusing input id...must synchronize to ensure multiple threads don't
                   // create
              String createLock = null;
              synchronized (this) {
                  createLock = (String) createSync.get(id);
                  if (createLock == null) {
                      createLock = id;
                      createSync.put(id, createLock);
                  }
              }
              synchronized (createLock) {
                  iSession = (ISession) _store.getFromMemory(id);
                  if (iSession == null) { // normal case
                      iSession = _store.createSession(id, false);
                      if (sessionVersion != -1) {
                          iSession.setVersion(sessionVersion);
                      }
                      createSync.remove(id);
                  } else { // very rare case - another thread just created so return same session
                      createSync.remove(id);
                      created = false;
                  }
              } // end of sync on createLock
          }
  
          /*- PM46948 A problem can occur when simultaneous requests for the same session are being processed 
           * on two or more servers and session persistence is enabled. This scenario means that 
           * session affinity is broken.  By spec, session affinity should be maintained.
           * 
           * In tWAS, we handle this case anyways because we do not want to return a null.  In this situation, 
           * a duplicate id on the backend is detected by this JVM, hence _store.createSession returned null for iSession.
           * 
           * In lWAS, we currently cannot distinguish duplicate key exceptions from other problems,
           * so BackedStore#createSession does not return null. As a result, we do not encounter an NPE,
           * but we also don't handle this scenario as gracefully as tWAS. PM46948 should be ported to lWAS
           * if the session manager can detect duplicate key exceptions in the future.
           */
  
          iSession.incrementRefCount();
  
          if (created) {
              iSession.setMaxInactiveInterval(_sessionTimeout);
              _sessionEventDispatcher.sessionCreated(iSession);
          }
  
          if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
              LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, methodNames[CREATE_ISESSION]);
          }
          return iSession;
      }