个人随笔
目录
关于Druid重试机制的问题及解决方案
2020-06-12 22:40:39

使用了Druid作为数据库连接池，当数据源链接失败时，报出了以下错误：

  1. 019-04-09 10:09:36  [Druid-ConnectionPool-Create-2053591126] [ com.alibaba.druid.pool.DruidDataSource ] [ 53 ] [ ERROR ] create connection SQLException, url: jdbc:mysql://*.*.*.*:3306/*?characterEncoding=utf-8&useSSL=false, errorCode 1045, state 28000
  2. java.sql.SQLException: Access denied for user 'malluser'@'*.*.*.*' (using password: YES)
  3.     at com.mysql.cj.jdbc.exceptions.SQLError.createSQLException(SQLError.java:545) ~[mysql-connector-java-6.0.6.jar:6.0.6]
  4.     at com.mysql.cj.jdbc.exceptions.SQLError.createSQLException(SQLError.java:513) ~[mysql-connector-java-6.0.6.jar:6.0.6]
  5.     at com.mysql.cj.jdbc.exceptions.SQLExceptionsMapping.translateException(SQLExceptionsMapping.java:115) ~[mysql-connector-java-6.0.6.jar:6.0.6]
  6. ...

对于错误相信大家一看都明白是怎么回事，但是问题是Druid会一直不停的对数据源进行重试连接，这样的话我们的日志很快就爆了，为什么Druid会一直进行重试呢？首先让我们看一下源码：

  1. public class CreateConnectionTask implements Runnable {
  3.         private int errorCount = 0;
  5.         @Override
  6.         public void run() {
  7.             runInternal();
  8.         }
  10.         private void runInternal() {
  11.             for (;;) {
  13.                 // addLast
  14.                 lock.lock();
  15.                 try {
  16.                     if (closed || closing) {
  17.                         createTaskCount--;
  18.                         return;
  19.                     }
  21.                     boolean emptyWait = true;
  23.                     if (createError != null && poolingCount == 0) {
  24.                         emptyWait = false;
  25.                     }
  27.                     if (emptyWait) {
  28.                         // 必须存在线程等待，才创建连接
  29.                         if (poolingCount >= notEmptyWaitThreadCount //
  30.                                 && !(keepAlive && activeCount + poolingCount < minIdle)) {
  31.                             createTaskCount--;
  32.                             return;
  33.                         }
  35.                         // 防止创建超过maxActive数量的连接
  36.                         if (activeCount + poolingCount >= maxActive) {
  37.                             createTaskCount--;
  38.                             return;
  39.                         }
  40.                     }
  41.                 } finally {
  42.                     lock.unlock();
  43.                 }
  45.                 PhysicalConnectionInfo physicalConnection = null;
  47.                 try {
  48.                     physicalConnection = createPhysicalConnection();
  49.                     setFailContinuous(false);
  50.                 } catch (OutOfMemoryError e) {
  51.                     LOG.error("create connection OutOfMemoryError, out memory. ", e);
  53.                     errorCount++;
  54.                     if (errorCount > connectionErrorRetryAttempts && timeBetweenConnectErrorMillis > 0) {
  55.                         // fail over retry attempts
  56.                         setFailContinuous(true);
  57.                         if (failFast) {
  58.                             lock.lock();
  59.                             try {
  60.                                 notEmpty.signalAll();
  61.                             } finally {
  62.                                 lock.unlock();
  63.                             }
  64.                         }
  66.                         if (breakAfterAcquireFailure) {
  67.                             lock.lock();
  68.                             try {
  69.                                 createTaskCount--;
  70.                             } finally {
  71.                                 lock.unlock();
  72.                             }
  73.                             return;
  74.                         }
  76.                         this.errorCount = 0; // reset errorCount
  77.                         if (closing || closed) {
  78.                             createTaskCount--;
  79.                             return;
  80.                         }
  81.                         createSchedulerFuture = createScheduler.schedule(this, timeBetweenConnectErrorMillis, TimeUnit.MILLISECONDS);
  82.                         return;
  83.                     }
  84.                 } catch (SQLException e) {
  85.                     LOG.error("create connection SQLException, url: " + jdbcUrl, e);
  87.                     errorCount++;
  88.                     if (errorCount > connectionErrorRetryAttempts && timeBetweenConnectErrorMillis > 0) {
  89.                         // fail over retry attempts
  90.                         setFailContinuous(true);
  91.                         if (failFast) {
  92.                             lock.lock();
  93.                             try {
  94.                                 notEmpty.signalAll();
  95.                             } finally {
  96.                                 lock.unlock();
  97.                             }
  98.                         }
  100.                         if (breakAfterAcquireFailure) {
  101.                             lock.lock();
  102.                             try {
  103.                                 createTaskCount--;
  104.                             } finally {
  105.                                 lock.unlock();
  106.                             }
  107.                             return;
  108.                         }
  110.                         this.errorCount = 0; // reset errorCount
  111.                         if (closing || closed) {
  112.                             createTaskCount--;
  113.                             return;
  114.                         }
  115.                         createSchedulerFuture = createScheduler.schedule(this, timeBetweenConnectErrorMillis, TimeUnit.MILLISECONDS);
  116.                         return;
  117.                     }
  118.                 } catch (RuntimeException e) {
  119.                     LOG.error("create connection RuntimeException", e);
  120.                     // unknow fatal exception
  121.                     setFailContinuous(true);
  122.                     continue;
  123.                 } catch (Error e) {
  124.                     lock.lock();
  125.                     try {
  126.                         createTaskCount--;
  127.                     } finally {
  128.                         lock.unlock();
  129.                     }
  130.                     LOG.error("create connection Error", e);
  131.                     // unknow fatal exception
  132.                     setFailContinuous(true);
  133.                     break;
  134.                 } catch (Throwable e) {
  135.                     LOG.error("create connection unexecpted error.", e);
  136.                     break;
  137.                 }
  139.                 if (physicalConnection == null) {
  140.                     continue;
  141.                 }
  143.                 boolean result = put(physicalConnection);
  144.                 if (!result) {
  145.                     JdbcUtils.close(physicalConnection.getPhysicalConnection());
  146.                     LOG.info("put physical connection to pool failed.");
  147.                 }
  148.                 break;
  149.             }
  150.         }
  151.     }
  153. public class CreateConnectionThread extends Thread {
  155.         public CreateConnectionThread(String name){
  156.             super(name);
  157.             this.setDaemon(true);
  158.         }
  160.         public void run() {
  161.             initedLatch.countDown();
  163.             long lastDiscardCount = 0;
  164.             int errorCount = 0;
  165.             for (;;) {
  166.                 // addLast
  167.                 try {
  168.                     lock.lockInterruptibly();
  169.                 } catch (InterruptedException e2) {
  170.                     break;
  171.                 }
  173.                 long discardCount = DruidDataSource.this.discardCount;
  174.                 boolean discardChanged = discardCount - lastDiscardCount > 0;
  175.                 lastDiscardCount = discardCount;
  177.                 try {
  178.                     boolean emptyWait = true;
  180.                     if (createError != null
  181.                             && poolingCount == 0
  182.                             && !discardChanged) {
  183.                         emptyWait = false;
  184.                     }
  186.                     if (emptyWait
  187.                             && asyncInit && createCount.get() < initialSize) {
  188.                         emptyWait = false;
  189.                     }
  191.                     if (emptyWait) {
  192.                         // 必须存在线程等待，才创建连接
  193.                         if (poolingCount >= notEmptyWaitThreadCount //
  194.                                 && !(keepAlive && activeCount + poolingCount < minIdle)) {
  195.                             empty.await();
  196.                         }
  198.                         // 防止创建超过maxActive数量的连接
  199.                         if (activeCount + poolingCount >= maxActive) {
  200.                             empty.await();
  201.                             continue;
  202.                         }
  203.                     }
  205.                 } catch (InterruptedException e) {
  206.                     lastCreateError = e;
  207.                     lastErrorTimeMillis = System.currentTimeMillis();
  209.                     if (!closing) {
  210.                         LOG.error("create connection Thread Interrupted, url: " + jdbcUrl, e);
  211.                     }
  212.                     break;
  213.                 } finally {
  214.                     lock.unlock();
  215.                 }
  217.                 PhysicalConnectionInfo connection = null;
  219.                 try {
  220.                     connection = createPhysicalConnection();
  221.                     setFailContinuous(false);
  222.                 } catch (SQLException e) {
  223.                     LOG.error("create connection SQLException, url: " + jdbcUrl + ", errorCode " + e.getErrorCode()
  224.                               + ", state " + e.getSQLState(), e);
  226.                     errorCount++;
  227.                     if (errorCount > connectionErrorRetryAttempts && timeBetweenConnectErrorMillis > 0) {
  228.                         // fail over retry attempts
  229.                         setFailContinuous(true);
  230.                         if (failFast) {
  231.                             lock.lock();
  232.                             try {
  233.                                 notEmpty.signalAll();
  234.                             } finally {
  235.                                 lock.unlock();
  236.                             }
  237.                         }
  239.                         if (breakAfterAcquireFailure) {
  240.                             break;
  241.                         }
  243.                         try {
  244.                             Thread.sleep(timeBetweenConnectErrorMillis);
  245.                         } catch (InterruptedException interruptEx) {
  246.                             break;
  247.                         }
  248.                     }
  249.                 } catch (RuntimeException e) {
  250.                     LOG.error("create connection RuntimeException", e);
  251.                     setFailContinuous(true);
  252.                     continue;
  253.                 } catch (Error e) {
  254.                     LOG.error("create connection Error", e);
  255.                     setFailContinuous(true);
  256.                     break;
  257.                 }
  259.                 if (connection == null) {
  260.                     continue;
  261.                 }
  263.                 boolean result = put(connection);
  264.                 if (!result) {
  265.                     JdbcUtils.close(connection.getPhysicalConnection());
  266.                     LOG.info("put physical connection to pool failed.");
  267.                 }
  269.                 errorCount = 0; // reset errorCount
  270.             }
  271.         }
  272.     }

从源码中我们可以看到，线程中使用了无参for循环再一直尝试进行数据源连接，代码中【errorCount > connectionErrorRetryAttempts && timeBetweenConnectErrorMillis > 0】当满足该判断条件时就会进行重试连接，接下来我们看一下源码中这两个属性值设置的是什么呢？（源码过长，只展示我们需要的代码，其他属性信息可自行扒源码~）

  1.  private static final long                          serialVersionUID = 1L;
  3.     public final static int                            DEFAULT_INITIAL_SIZE = 0;
  4.     public final static int                            DEFAULT_MAX_ACTIVE_SIZE = 8;
  5.     public final static int                            DEFAULT_MAX_IDLE= 8;
  6.     public final static int                            DEFAULT_MIN_IDLE= 0;
  7.     public final static int                            DEFAULT_MAX_WAIT = -1;
  8.     public final static String                         DEFAULT_VALIDATION_QUERY  =null;//
  9.     public final static boolean                        DEFAULT_TEST_ON_BORROW = false;
  10.     public final static boolean                        DEFAULT_TEST_ON_RETURN = false;
  11.     public final static boolean                        DEFAULT_WHILE_IDLE= true;
  12.     public static final long                         DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS = 60 * 1000L;
  13.     public static final long                           DEFAULT_TIME_BETWEEN_CONNECT_ERROR_MILLIS = 500;
  14.     public static final int                            DEFAULT_NUM_TESTS_PER_EVICTION_RUN        = 3;
  15. /*****************************华丽的分割线中间省略代码若干行*********************************/
  16. protected volatile long                            timeBetweenEvictionRunsMillis             = DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS;
  17.     protected int                                      connectionErrorRetryAttempts              = 1;
  18.     protected boolean                                  breakAfterAcquireFailure                  = false;

从中这段代码中我们可以看到connectionErrorRetryAttempts值为1，timeBetweenConnectErrorMillis值为60000，而breakAfterAcquireFailure值为false，因此当我们数据源连接失败后，就会不断的进行重试连接，因此我对于对于该如何解决这样的问题我们就有了答案:

1.若不想让重试，我们可以设置breakAfterAcquireFailure(true);connectionErrorRetryAttempts(0);
2.若想要设置多久重试，我们只需要设置timeBetweenConnectErrorMillis(time）；

action：经过亲测，直接在配置文件中配置属性并不能读取到（Druid设计时就这样，大神的思维暂时还不能参悟~），我们可直接将值写入程序当中，如下：

  1. private static void Init() {
  2.         try {
  3.             Properties properties = loadPropertiesFile("db.properties");
  4.             druidDataSource = (DruidDataSource) DruidDataSourceFactory.createDataSource(properties); // DruidDataSrouce工厂模式
  5.             // TODO 调试配置，用完删除
  6.             druidDataSource.setRemoveAbandoned(true);
  7.             druidDataSource.setRemoveAbandonedTimeout(600);
  8.             druidDataSource.setLogAbandoned(true);
  9. //            druidDataSource.setBreakAfterAcquireFailure(true);
  10.             druidDataSource.setTimeBetweenConnectErrorMillis(60000);
  11. //            druidDataSource.setConnectionErrorRetryAttempts(0);
  13.         } catch (Exception e) {
  14.             logger.error(DbPoolConnection.class, e);
  15.         }

当然若是想要方便以后修改，我们可以在properties文件中设置该值，读取出来配置文件的值再赋值给druidDataSource。

到这里，本文就结束了，如有不当之处，欢迎指正！

————————————————

版权声明：本文为CSDN博主「czzxueyang」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sadness_lxy/java/article/details/89136418

 2277

啊！这个可能是世界上最丑的留言输入框功能~


当然，也是最丑的留言列表

有疑问发邮件到 : suibibk@qq.com 侵权立删
Copyright : 个人随笔   备案号 : 粤ICP备18099399号-2