登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›JDBC游标读不生效导致OOM问题排查分析

JDBC游标读不生效导致OOM问题排查分析

钿稳铆 8 小时前
JDBC游标读不生效导致OOM问题排查分析

问题描述

程序使用游标读分批读取MySQL的数据，但是程序容器却发生OOM
基本信息

MySQL版本：8.0.25
JDBC版本：8.0.25
JDBC配置：
  1. connectionProperties=useUnicode=true;autoReconnect=true;defaultFetchSize=800;useServerPrepStmts=false;rewriteBatchedStatements=true;useCompression=true;useCursorFetch=true;allowMultiQueries=true
复制代码
批量程序的OOM日志：
1.png

2.png

问题分析

获取dump下来的内存快照后，使用jdk自带的Java visualVM打开后，找到右侧最大的对象：
3.png

发现java.lang.Object[]最大，点击后发现里面存的是ByteArrayRow类型对象，它是数据库的游标对象，说明在查询数据库的过程中，内存已经溢出，还没来得及转换成实体类，说明此时游标读失效。
4.png

通过查看堆栈上的线程报错信息
5.png

显示的代码的流程调用的是ClientPreparedStatement类的方法，没有调用ServerPreparedStatement类的方法，调用的是客户端来执行，此时是普通读。
利用游标读demo测试，发现游标读的调用时走ServerPreparedStatement类的方法（下图第3、4行），然后调用ServerPreparedQuery类的ServerPreparedQuery方法（下图第1行）
6.png

查看源码，ServerPreparedQuery方法中调用了packet.writeInteger(IntegerDataType.INT1, OPEN_CURSOR_FLAG)方法进行游标读。
7.png

ClientPreparedStatement：查询是在客户端准备的。这意味着所有的SQL语句处理，包括参数替换，都在客户端完成，然后作为一个整体发送到服务器，只能普通读。
ServerPreparedStatement：查询是在服务器端准备的。这意味着SQL语句和其参数在服务器上被处理，这可以利用服务器的某些优化特性，可以普通读、游标读、流式读。
进一步分析，PreparedStatement的具体实现什么时候确定是ClientPreparedStatement还是ServerPreparedStatement？
在调用Connection.prepareStatement()或Connection.prepareStatement(String sql, int resultSetType, int resultSetConcurrency)等方法时，JDBC驱动会根据当前的配置和数据库服务器的能力来确定使用哪种PreparedStatement实现。
  1. @Override
  2. public java.sql.PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
  3.     synchronized (getConnectionMutex()) {
  4.         checkClosed();
  6.         //
  7.         // FIXME: Create warnings if can't create results of the given type or concurrency
  8.         //
  9.         ClientPreparedStatement pStmt = null;
  11.         boolean canServerPrepare = true;
  13.         String nativeSql = this.processEscapeCodesForPrepStmts.getValue() ? nativeSQL(sql) : sql;
  15.         if (this.useServerPrepStmts.getValue() && this.emulateUnsupportedPstmts.getValue()) {
  16.             canServerPrepare = canHandleAsServerPreparedStatement(nativeSql);
  17.         }
  19.         if (this.useServerPrepStmts.getValue() && canServerPrepare) {
  20.             if (this.cachePrepStmts.getValue()) {
  21.                 synchronized (this.serverSideStatementCache) {
  22.                     pStmt = this.serverSideStatementCache.remove(new CompoundCacheKey(this.database, sql));
  24.                     if (pStmt != null) {
  25.                         ((com.mysql.cj.jdbc.ServerPreparedStatement) pStmt).setClosed(false);
  26.                         pStmt.clearParameters();
  27.                     }
  29.                     if (pStmt == null) {
  30.                         try {
  31.                             pStmt = ServerPreparedStatement.getInstance(getMultiHostSafeProxy(), nativeSql, this.database, resultSetType,
  32.                                     resultSetConcurrency);
  33.                             if (sql.length() < this.prepStmtCacheSqlLimit.getValue()) {
  34.                                 ((com.mysql.cj.jdbc.ServerPreparedStatement) pStmt).isCacheable = true;
  35.                             }
  37.                             pStmt.setResultSetType(resultSetType);
  38.                             pStmt.setResultSetConcurrency(resultSetConcurrency);
  39.                         } catch (SQLException sqlEx) {
  40.                             // Punt, if necessary
  41.                             if (this.emulateUnsupportedPstmts.getValue()) {
  42.                                 pStmt = (ClientPreparedStatement) clientPrepareStatement(nativeSql, resultSetType, resultSetConcurrency, false);
  44.                                 if (sql.length() < this.prepStmtCacheSqlLimit.getValue()) {
  45.                                     this.serverSideStatementCheckCache.put(sql, Boolean.FALSE);
  46.                                 }
  47.                             } else {
  48.                                 throw sqlEx;
  49.                             }
  50.                         }
  51.                     }
  52.                 }
  53.             } else {
  54.                 try {
  55.                     pStmt = ServerPreparedStatement.getInstance(getMultiHostSafeProxy(), nativeSql, this.database, resultSetType, resultSetConcurrency);
  57.                     pStmt.setResultSetType(resultSetType);
  58.                     pStmt.setResultSetConcurrency(resultSetConcurrency);
  59.                 } catch (SQLException sqlEx) {
  60.                     // Punt, if necessary
  61.                     if (this.emulateUnsupportedPstmts.getValue()) {
  62.                         pStmt = (ClientPreparedStatement) clientPrepareStatement(nativeSql, resultSetType, resultSetConcurrency, false);
  63.                     } else {
  64.                         throw sqlEx;
  65.                     }
  66.                 }
  67.             }
  68.         } else {
  69.             pStmt = (ClientPreparedStatement) clientPrepareStatement(nativeSql, resultSetType, resultSetConcurrency, false);
  70.         }
  72.         return pStmt;
  73.     }
  74. }
复制代码
通过debug发现，会走到16行的 canServerPrepare = canHandleAsServerPreparedStatement(nativeSql);
说明在jdbc配置useServerPrepStmts=true是生效的，emulateUnsupportedPstmts系统默认值就是true，判断成立。
继续debug，进入canHandleAsServerPreparedStatement方法
  1. private boolean canHandleAsServerPreparedStatement(String sql) throws SQLException {
  2.     if (sql == null || sql.length() == 0) {
  3.         return true;
  4.     }
  6.     if (!this.useServerPrepStmts.getValue()) {
  7.         return false;
  8.     }
  10.     boolean allowMultiQueries = this.propertySet.getBooleanProperty(PropertyKey.allowMultiQueries).getValue();
  12.     if (this.cachePrepStmts.getValue()) {
  13.         synchronized (this.serverSideStatementCheckCache) {
  14.             Boolean flag = this.serverSideStatementCheckCache.get(sql);
  16.             if (flag != null) {
  17.                 return flag.booleanValue();
  18.             }
  20.             boolean canHandle = StringUtils.canHandleAsServerPreparedStatementNoCache(sql, getServerVersion(), allowMultiQueries,
  21.                     this.session.getServerSession().isNoBackslashEscapesSet(), this.session.getServerSession().useAnsiQuotedIdentifiers());
  23.             if (sql.length() < this.prepStmtCacheSqlLimit.getValue()) {
  24.                 this.serverSideStatementCheckCache.put(sql, canHandle ? Boolean.TRUE : Boolean.FALSE);
  25.             }
  27.             return canHandle;
  28.         }
  29.     }
  31.     return StringUtils.canHandleAsServerPreparedStatementNoCache(sql, getServerVersion(), allowMultiQueries,
  32.             this.session.getServerSession().isNoBackslashEscapesSet(), this.session.getServerSession().useAnsiQuotedIdentifiers());
  33. }
复制代码
cachePrepStmts默认值是false，前面的判断是不成立的，直接走到最后的StringUtils类的canHandleAsServerPreparedStatementNoCache方法。
8.png
  1. public static boolean canHandleAsServerPreparedStatementNoCache(String sql, ServerVersion serverVersion, boolean allowMultiQueries,
  2.         boolean noBackslashEscapes, boolean useAnsiQuotes) {
  4.     // Can't use server-side prepare for CALL
  5.     if (startsWithIgnoreCaseAndNonAlphaNumeric(sql, "CALL")) {
  6.         return false;
  7.     }
  9.     boolean canHandleAsStatement = true;
  11.     boolean allowBackslashEscapes = !noBackslashEscapes;
  12.     String quoteChar = useAnsiQuotes ? """ : "'";
  14.     if (allowMultiQueries) {
  15.         if (StringUtils.indexOfIgnoreCase(0, sql, ";", quoteChar, quoteChar,
  16.                 allowBackslashEscapes ? StringUtils.SEARCH_MODE__ALL : StringUtils.SEARCH_MODE__MRK_COM_WS) != -1) {
  17.             canHandleAsStatement = false;
  18.         }
  19.     } else if (startsWithIgnoreCaseAndWs(sql, "XA ")) {
  20.         canHandleAsStatement = false;
  21.     } else if (startsWithIgnoreCaseAndWs(sql, "CREATE TABLE")) {
  22.         canHandleAsStatement = false;
  23.     } else if (startsWithIgnoreCaseAndWs(sql, "DO")) {
  24.         canHandleAsStatement = false;
  25.     } else if (startsWithIgnoreCaseAndWs(sql, "SET")) {
  26.         canHandleAsStatement = false;
  27.     } else if (StringUtils.startsWithIgnoreCaseAndWs(sql, "SHOW WARNINGS") && serverVersion.meetsMinimum(ServerVersion.parseVersion("5.7.2"))) {
  28.         canHandleAsStatement = false;
  29.     } else if (sql.startsWith("/* ping */")) {
  30.         canHandleAsStatement = false;
  31.     }
  33.     return canHandleAsStatement;
  34. }
复制代码
canHandleAsServerPreparedStatementNoCache是在不开启缓存的情况下是否能使用ServerPreparedStatement。
根据后续反馈，游标读不是一直不生效，只是在运行某个sql的时候不生效，为了隐私，这里将这个sql简化为
  1. select * from t;
复制代码
由于sql不是CALL开头而且jdbc的参数allowMultiQueries=true会走到15行的代码，indexOfIgnoreCase方法的意思是在字符串中查找子字符串的位置，忽略大小写，并有选择地跳过由给定标记限定的文本或在注释中的文本。
这行的代码意思在sql语句中查找;的位置，忽略''符号之间的内容，如果不存在，即返回-1，就允许使用ServerPreparedStatement，否则使用****ClientPreparedStatement。经过debug，确实会走到这里。
9.png

问题总结

问题发生路径：开启allowMultiQueries=true且当前sql带分号 ——>
canHandleAsServerPreparedStatementNoCache返回值为false ——>
canHandleAsServerPreparedStatement返回值为false  ——>
执行 (ClientPreparedStatement) clientPrepareStatement(nativeSql, resultSetType, resultSetConcurrency, false)返回ClientPreparedStatement ——>
客户端执行普通读。
使用建议


  • 默认地书写SQL时去掉后面的分号；
  • 不要开启allowMultiQueries=true，其默认值为false（默认设置下会影响到需要多语句执行的场景，可根据实际需要临时开启）。
全文完。

Enjoy GreatSQL
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
钿稳铆
8 小时前

0

粉丝关注

29

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫