for(Tenant t : tenantList){
      ApplicationChainContext.getCurrentContext().put(ApplicationChainContext.TENANT_ID,t.getId()+"");
      Optional<SaasUser> user = this.findByUserPhone(req.getUserPhone());
      user.ifPresent(u -> {
        count.getAndSet(count.get() + 1);
        LambdaUpdateWrapper<SaasUser> wrapper = new LambdaUpdateWrapper<>();
        String md5Pwd = Md5Utils.hash(req.getNewUserPwd());
        wrapper.eq(SaasUser::getId,user.get().getId());
        wrapper.set(SaasUser::getUserPwd,md5Pwd);
        this.update(wrapper);
      });
    }

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (this.closed) {
      throw new ExecutorException("Executor was closed.");
    } else {
      if (this.queryStack == 0 && ms.isFlushCacheRequired()) {
        this.clearLocalCache();
      }

      List list;
      try {
        ++this.queryStack;
        list = resultHandler == null ? (List)this.localCache.getObject(key) : null;
        if (list != null) {
          this.handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
        } else {
          list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
        }
      } finally {
        --this.queryStack;
      }

      if (this.queryStack == 0) {
        Iterator var8 = this.deferredLoads.iterator();

        while(var8.hasNext()) {
          BaseExecutor.DeferredLoad deferredLoad = (BaseExecutor.DeferredLoad)var8.next();
          deferredLoad.load();
        }

        this.deferredLoads.clear();
        if (this.configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
          this.clearLocalCache();
        }
      }

      return list;
    }
  }

 list = resultHandler == null ? (List)this.localCache.getObject(key) : null;
        if (list != null) {
          this.handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
        } else {
          list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
        }

if (queryStack == 0 && ms.isFlushCacheRequired()) {
   clearLocalCache();
  }

if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
    // issue #482
    clearLocalCache();
   }

mybatis-plus:
  configuration:
    local-cache-scope: statement

public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (this.closed) {
      throw new ExecutorException("Executor was closed.");
    } else {
      CacheKey cacheKey = new CacheKey();
      cacheKey.update(ms.getId());
      cacheKey.update(rowBounds.getOffset());
      cacheKey.update(rowBounds.getLimit());
      cacheKey.update(boundSql.getSql());
      List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
      TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
      Iterator var8 = parameterMappings.iterator();

      while(var8.hasNext()) {
        ParameterMapping parameterMapping = (ParameterMapping)var8.next();
        if (parameterMapping.getMode() != ParameterMode.OUT) {
          String propertyName = parameterMapping.getProperty();
          Object value;
          if (boundSql.hasAdditionalParameter(propertyName)) {
            value = boundSql.getAdditionalParameter(propertyName);
          } else if (parameterObject == null) {
            value = null;
          } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
            value = parameterObject;
          } else {
            MetaObject metaObject = this.configuration.newMetaObject(parameterObject);
            value = metaObject.getValue(propertyName);
          }

          cacheKey.update(value);
        }
      }

      if (this.configuration.getEnvironment() != null) {
        cacheKey.update(this.configuration.getEnvironment().getId());
      }

      return cacheKey;
    }
  }

 public Optional<SaasUser> findByUserPhone(String userPhone) {
    LambdaQueryWrapper<SaasUser> wrapper = new LambdaQueryWrapper<>();
    wrapper.eq(SaasUser::getUserPhone,userPhone);
    wrapper.apply("{0} = {0}",UUID.randomUUID().toString());
    SaasUser saasUser = getBaseMapper().selectOne(wrapper);
    return Optional.ofNullable(saasUser);
  }

wrapper.apply("{0} = {0}",UUID.randomUUID().toString());