docs: @Override
      public ISession createSession(String id, boolean newId) {
          // assert (id!=null);
          if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINER)) {
              StringBuffer sb = new StringBuffer("{").append(id).append(",").append(newId).append("} ").append(appNameForLogging);
              LoggingUtil.SESSION_LOGGER_CORE.entering(methodClassName, methodNames[CREATE_SESSION], sb.toString());
          }
          MemorySession sess = null;
  
          // need to test on a different language
          // try creating a temporary logger with the old resource bundle, and then
          // changing the environment to French or something
          if (inProcessOfStopping) {
              throwException("SessionContext.createWhenStop");
          }
          if ((!_smc.getEnableOverflow()) && (_sessions.size() >= _smc.getInMemorySize())) {
              // if we know we're in an overflow situation, don't bother
              // creating a new session
              if (_sessionStatistics != null) {
                  _sessionStatistics.incNoRoomForNewSession();
              }
              sess = overflowSession;
          }
          // We expect the second part of check below - _sessions.get(id) == null --
          // to pass unless
          // the id generator generates a dup. This really should never happen.
          // The synchronization in SessionManager.createISession will prevent
          // multiple threads
          // with the same incoming id from both getting into this code. We're no
          // longer using
          // the newId parm...it could be removed, but its now part of the IStore
          // interface.
          if ((sess == null) && (_sessions.get(id) == null)) {
              if(!_removeAttrOnInvalidate)
                  sess = new MemorySession(this, id, _storeCallback);
              else{
                  if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                      LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[CREATE_SESSION], "Create MemorySession with _removeAttrOnInvalidate -->" + _removeAttrOnInvalidate );
                  }
                  sess = new MemorySession(this, id, _storeCallback, _removeAttrOnInvalidate);
              }
              sess.setUserName(ANONYMOUS_USER);
              // since this was a newly created session, we need to update the
              // lastAccessTime to the create time
              sess.updateLastAccessTime(sess.getCreationTime());
              try {
                  _sessions.put(id, sess);
              } catch (TooManySessionsException tmse) {
                  // could catch this exception if multiple threads get past the
                  // first overflow check and then attempt to do the sessions.put
                  sess = overflowSession;
              }
          }
  
          // Returns a new session if everything is good
          // Returns an overflowSession is overflow is not allowed and we've already
          // hit the maximum number in memory
          // Returns null if there was an existing session with this key - should
          // never happen
  
          if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
              LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, methodNames[CREATE_SESSION], sess);
          }
          return sess;
      }