Change to use internal Timer for heartBeat

Author: rbygrave

src/main/java/org/avaje/datasource/pool/ConnectionPool.java

@@ -20,6 +20,8 @@
 import java.util.Map.Entry;
 import java.util.Properties;
 import java.util.Set;
+import java.util.Timer;
+import java.util.TimerTask;
 
 /**
  * A robust DataSource implementation.
@@ -159,17 +161,17 @@ public class ConnectionPool implements DataSourcePool {
 
   private final PooledConnectionQueue queue;
 
+  private final Timer heartBeatTimer;
+
   /**
    * Used to find and close() leaked connections. Leaked connections are
    * thought to be busy but have not been used for some time. Each time a
    * connection is used it sets it's lastUsedTime.
    */
   private long leakTimeMinutes;
 
-  private final Runnable heartbeatRunnable = new HeartBeatRunnable();
-
-  public ConnectionPool(String name, DataSourceConfig params, DataSourceAlert notify) {
-    this(name, params, notify, null);
+  public ConnectionPool(String name, DataSourceConfig params) {
+    this(name, params, null, null);
   }
 
   public ConnectionPool(String name, DataSourceConfig params, DataSourceAlert notify, DataSourcePoolListener listener) {
@@ -222,12 +224,17 @@ public ConnectionPool(String name, DataSourceConfig params, DataSourceAlert noti
 
     try {
       initialise();
+      int freqMillis = heartbeatFreqSecs * 1000;
+      heartBeatTimer = new Timer(name+".heartBeat");
+      if (freqMillis > 0) {
+        heartBeatTimer.scheduleAtFixedRate(new HeartBeatRunnable(), freqMillis, freqMillis);
+      }
     } catch (SQLException ex) {
       throw new RuntimeException(ex);
     }
   }
 
-  class HeartBeatRunnable implements Runnable {
+  class HeartBeatRunnable extends TimerTask {
     @Override
     public void run() {
       checkDataSource();
@@ -356,24 +363,6 @@ private void notifyDataSourceIsUp() {
     }
   }
 
-
-  /**
-   * Return the heartbeat frequency in seconds.
-   * <p>
-   * This is the frequency that the heartbeat runnable should be run.
-   * </p>
-   */
-  public int getHeartbeatFreqSecs() {
-    return heartbeatFreqSecs;
-  }
-
-  /**
-   * Returns the Runnable used to check the dataSource using a heartbeat query.
-   */
-  public Runnable getHeartbeatRunnable() {
-    return heartbeatRunnable;
-  }
-
   /**
    * Trim connections (in the free list) based on idle time and maximum age.
    */
@@ -760,6 +749,7 @@ public void testAlert() {
    */
   @Override
   public void shutdown(boolean deregisterDriver) {
+    heartBeatTimer.cancel();
     queue.shutdown();
     if (deregisterDriver) {
       deregisterDriver();

src/test/java/org/avaje/datasource/pool/ConnectionPoolSpeedTest.java

@@ -0,0 +1,93 @@
+package org.avaje.datasource.pool;
+
+import org.avaje.datasource.DataSourceConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.Test;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Random;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+public class ConnectionPoolSpeedTest {
+
+  private Logger logger = LoggerFactory.getLogger(ConnectionPoolSpeedTest.class);
+
+  private ConnectionPool pool;
+
+  private Random random = new Random();
+
+  private int total;
+
+  ConnectionPoolSpeedTest() {
+    pool = createPool();
+  }
+
+  private ConnectionPool createPool() {
+
+    DataSourceConfig config = new DataSourceConfig();
+    config.setDriver("org.h2.Driver");
+    config.setUrl("jdbc:h2:mem:tests");
+    config.setUsername("sa");
+    config.setPassword("");
+    config.setMinConnections(2);
+    config.setMaxConnections(100);
+
+    return new ConnectionPool("testspeed", config);
+  }
+
+  @AfterClass
+  public void after() {
+    pool.shutdown(false);
+  }
+
+  @Test
+  public void test() throws SQLException, InterruptedException {
+
+    warm();
+
+    total = 0;
+
+    long startNano = System.nanoTime();
+
+    perform();
+
+    long exeNano = System.nanoTime() - startNano;
+    long avgNanos = exeNano / total;
+
+    logger.info("avgNanos[{}] total[{}]", avgNanos, total);
+
+    assertThat(avgNanos).isLessThan(300);
+  }
+
+  private void perform() throws SQLException {
+    for (int i = 0; i < 10000000; i++) {
+      getAndCloseSome();
+    }
+  }
+
+  private void warm() throws SQLException {
+    for (int i = 0; i < 50; i++) {
+      getAndCloseSome();
+    }
+  }
+
+  private void getAndCloseSome() throws SQLException {
+
+    int num = random.nextInt(5);
+    Connection[] bunch = new Connection[num];
+    for (int i = 0; i < num; i++) {
+      bunch[i] = pool.getConnection();
+    }
+
+    for (Connection connection : bunch) {
+      connection.close();
+    }
+
+    total += num;
+  }
+
+}

src/test/java/org/avaje/datasource/pool/ConnectionPoolTest.java

@@ -2,6 +2,7 @@
 
 import org.avaje.datasource.DataSourceConfig;
 import org.avaje.datasource.PoolStatistics;
+import org.testng.annotations.AfterClass;
 import org.testng.annotations.Test;
 
 import java.sql.Connection;
@@ -27,7 +28,12 @@ private ConnectionPool createPool() {
     config.setMinConnections(2);
     config.setMaxConnections(4);
 
-    return new ConnectionPool("test", config, null);
+    return new ConnectionPool("test", config);
+  }
+
+  @AfterClass
+  public void after() {
+    pool.shutdown(false);
   }
 
   @Test
@@ -56,7 +62,7 @@ public void getConnection_expect_poolGrowsAboveMin() throws SQLException {
     assertThat(pool.getStatus(false).getFree()).isEqualTo(3);
   }
 
-  @Test
+  @Test(dependsOnMethods = "getConnection_expect_poolGrowsAboveMin")
   public void getConnection_getStatistics() throws SQLException, InterruptedException {
 
     pool.getStatistics(true);

src/test/java/org/avaje/datasource/pool/ConnectionPoolTrimIdleTest.java

@@ -0,0 +1,61 @@
+package org.avaje.datasource.pool;
+
+import org.avaje.datasource.DataSourceConfig;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.Test;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+public class ConnectionPoolTrimIdleTest {
+
+  private ConnectionPool pool;
+
+  ConnectionPoolTrimIdleTest() {
+    pool = createPool();
+  }
+
+  private ConnectionPool createPool() {
+
+    DataSourceConfig config = new DataSourceConfig();
+    config.setDriver("org.h2.Driver");
+    config.setUrl("jdbc:h2:mem:tests");
+    config.setUsername("sa");
+    config.setPassword("");
+    config.setMinConnections(2);
+    config.setMaxConnections(10);
+    config.setMaxInactiveTimeSecs(1);
+    config.setTrimPoolFreqSecs(1);
+    config.setHeartbeatFreqSecs(1);
+
+    return new ConnectionPool("testidle", config);
+  }
+
+  @AfterClass
+  public void after() {
+    pool.shutdown(false);
+  }
+
+  @Test
+  public void test() throws SQLException, InterruptedException {
+
+    Connection con1 = pool.getConnection();
+    Connection con2 = pool.getConnection();
+    Connection con3 = pool.getConnection();
+    Connection con4 = pool.getConnection();
+
+    con1.close();
+    con2.close();
+    con3.close();
+    con4.close();
+
+    assertThat(pool.getStatus(false).getFree()).isEqualTo(4);
+
+    Thread.sleep(5000);
+
+    assertThat(pool.getStatus(false).getFree()).isEqualTo(2);
+
+  }
+}