Druid-Verbindungspool mit niedriger Version + MySQL-Treiber 8.0 führt zu Thread-Blockierungen und Leistungseinschränkungen

"http-nio-5366-exec-48" #210 Daemon prio=5 os_prio=0 tid=0x00000000023d0800 nid=0x3be9 wartet auf Monitoreintrag [0x00007fa4c1400000]
   java.lang.Thread.State: BLOCKIERT (auf dem Objektmonitor)
        bei org.springframework.boot.web.embedded.tomcat.TomcatEmbeddedWebappClassLoader.loadClass(TomcatEmbeddedWebappClassLoader.java:66)
        - Wartet auf die Sperre <0x0000000775af0960> (ein java.lang.Object)
        bei org.apache.catalina.loader.WebappClassLoaderBase.loadClass(WebappClassLoaderBase.java:1186)
        bei com.alibaba.druid.util.Utils.loadClass(Utils.java:220)
        bei com.alibaba.druid.util.MySqlUtils.getLastPacketReceivedTimeMs(MySqlUtils.java:372)

öffentliche Klasse MySqlUtils {

    öffentliche statische lange getLastPacketReceivedTimeMs (Verbindung conn) wirft SQLException {
        wenn (class_connectionImpl == null und !class_connectionImpl_Error) {
            versuchen {
                class_connectionImpl = Utils.loadClass("com.mysql.jdbc.MySQLConnection");
            } catch (Auslösbarer Fehler) {
                class_connectionImpl_Error = wahr;
            }
        }

        wenn (class_connectionImpl == null) {
            Rückgabe -1;
        }

        wenn (method_getIO == null und !method_getIO_error) {
            versuchen {
                method_getIO = class_connectionImpl.getMethod("getIO");
            } catch (Auslösbarer Fehler) {
                method_getIO_error = wahr;
            }
        }

        wenn (method_getIO == null) {
            Rückgabe -1;
        }

        wenn (class_MysqlIO == null && !class_MysqlIO_Error) {
            versuchen {
                Klasse_MysqlIO = Utils.loadClass("com.mysql.jdbc.MysqlIO");
            } catch (Auslösbarer Fehler) {
                Klasse_MysqlIO_Error = wahr;
            }
        }

        wenn (class_MysqlIO == null) {
            Rückgabe -1;
        }

        if (method_getLastPacketReceivedTimeMs == null && !method_getLastPacketReceivedTimeMs_error) {
            versuchen {
                Methode Methode = class_MysqlIO.getDeclaredMethod("getLastPacketReceivedTimeMs");
                Methode.SetAccessible(true);
                method_getLastPacketReceivedTimeMs = Methode;
            } catch (Auslösbarer Fehler) {
                method_getLastPacketReceivedTimeMs_error = true;
            }
        }

        wenn (method_getLastPacketReceivedTimeMs == null) {
            Rückgabe -1;
        }

        versuchen {
            Objekt connImpl = conn.unwrap(class_connectionImpl);
            wenn (connImpl == null) {
                Rückgabe -1;
            }

            Objekt mysqlio = method_getIO.invoke(connImpl);
            Lange ms = (Lang) method_getLastPacketReceivedTimeMs.invoke(mysqlio);
            return ms.langerWert();
        } Fang (IllegalArgumentException e) {
            neue SQLException werfen("getLastPacketReceivedTimeMs-Fehler", e);
        } Fang (IllegalAccessException e) {
            neue SQLException werfen("getLastPacketReceivedTimeMs-Fehler", e);
        } Fang (InvocationTargetException e) {
            neue SQLException werfen("getLastPacketReceivedTimeMs-Fehler", e);
        }
    }

öffentliche Klasse Utils {

    öffentliche statische Klasse<?> loadClass(String Klassenname) {
        Klasse<?> clazz = null;

        wenn (Klassenname == null) {
            gibt null zurück;
        }

        versuchen {
            gibt Class.forName(Klassenname) zurück;
        } Fang (ClassNotFoundException e) {
            // überspringen
        }

        ctxClassLoader = Thread.currentThread().getContextClassLoader();
        if (ctxClassLoader != null) {
            versuchen {
                clazz = ctxClassLoader.loadClass(Klassenname);
            } Fang (ClassNotFoundException e) {
                // überspringen
            }
        }

        Rückgabeklazz;
    }

 öffentliche Klasse<?> loadClass(Stringname, Boolesche Auflösung) wirft ClassNotFoundException {
  synchronisiert (JreCompat.isGraalAvailable() ? dies : getClassLoadingLock(name)) {
   Klasse<?> Ergebnis = findExistingLoadedClass(Name);
   Ergebnis = (Ergebnis != null)? Ergebnis: doLoadClass(Name);
   wenn (Ergebnis == null) {
    wirf eine neue ClassNotFoundException(Name);
   }
   returniere „solveIfNecessary“ (Ergebnis, Lösung);
  }
 }

öffentliche abstrakte Klasse DruidAbstractDataSource erweitert WrapperAdapter implementiert DruidAbstractDataSourceMBean, DataSource, DataSourceProxy, Serializable {

    geschützter Boolescher Wert testConnectionInternal(DruidConnectionHolder-Inhaber, Verbindungsverbindung) {
        Zeichenfolge sqlFile = JdbcSqlStat.getContextSqlFile();
        Zeichenfolge sqlName = JdbcSqlStat.getContextSqlName();

        if (sqlFile != null) {
            JdbcSqlStat.setContextSqlFile(null);
        }
        if (sqlName != null) {
            JdbcSqlStat.setContextSqlName(null);
        }
        versuchen {
            if (validConnectionChecker != null) {
                Boolescher Wert gültig = validConnectionChecker.isValidConnection(conn, validationQuery, validationQueryTimeout);
                lange currentTimeMillis = System.currentTimeMillis();
                wenn (Inhaber != null) {
                    Inhaber.letzteValidTimeMillis = aktuelleTimeMillis;
                    Inhaber.lastExecTimeMillis = aktuelleTimeMillis;
                }

                if (valid && isMySql) { // nicht ausgenommener Zweig
                    lange lastPacketReceivedTimeMs = MySqlUtils.getLastPacketReceivedTimeMs(conn);
                    wenn (lastPacketReceivedTimeMs > 0) {
                        lange mysqlIdleMillis = aktuelleZeitMillis - letztePaketempfangszeitMs;
                        wenn (lastPacketReceivedTimeMs > 0 //
                                && mysqlIdleMillis >= timeBetweenEvictionRunsMillis) {
                            Verbindung verwerfen(Inhaber);
                            String errorMsg = "Lange Zeit keine empfangene Verbindung verwerfen."
                                    + ", jdbcUrl: " + jdbcUrl
                                    + ", jdbcUrl: " + jdbcUrl
                                    + ", lastPacketReceivedIdleMillis: " + mysqlIdleMillis;
                            LOG.error(Fehlermeldung);
                            gibt false zurück;
                        }
                    }
                }

                if (gültig && bei schwerwiegendem Fehler) {
                    sperre.sperre();
                    versuchen {
                        if (bei schwerwiegendem Fehler) {
                            bei schwerwiegendem Fehler = falsch;
                        }
                    Endlich
                        sperren.entsperren();
                    }
                }

                Rückgabe gültig;
            }

            wenn (conn.isClosed()) {
                gibt false zurück;
            }

            if (null == Validierungsabfrage) {
                gibt true zurück;
            }

            Anweisung stmt = null;
            Ergebnismenge rset = null;
            versuchen {
                stmt = conn.createStatement();
                wenn (getValidationQueryTimeout() > 0) {
                    stmt.setQueryTimeout(validationQueryTimeout);
                }
                rset = stmt.executeQuery(Validierungsabfrage);
                wenn (!rset.next()) {
                    gibt false zurück;
                }
            Endlich
                JdbcUtils.close(rset);
                JdbcUtils.close(stmt);
            }

            if (bei schwerwiegendem Fehler) {
                sperre.sperre();
                versuchen {
                    if (bei schwerwiegendem Fehler) {
                        bei schwerwiegendem Fehler = falsch;
                    }
                Endlich
                    sperren.entsperren();
                }
            }

            gibt true zurück;
        } fangen (Wurfbeispiel) {
            // überspringen
            gibt false zurück;
        Endlich
            if (sqlFile != null) {
                JdbcSqlStat.setContextSqlFile(sqlFile);
            }
            if (sqlName != null) {
                JdbcSqlStat.setContextSqlName(sqlName);
            }
        }
    }