Minor improvements

Author: rPraml

ebean-datasource/src/main/java/io/ebean/datasource/pool/ConnectionPool.java

@@ -8,6 +8,8 @@
 import java.util.*;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.LongAdder;
@@ -733,19 +735,45 @@ private void stopHeartBeatIfRunning() {
     }
   }
 
-  void execute(Runnable runable) {
+  static class AsyncCloser implements Runnable {
+    final PooledConnection pc;
+    final boolean logErrors;
+
+    public AsyncCloser(PooledConnection pc, boolean logErrors) {
+      this.pc = pc;
+      this.logErrors = logErrors;
+    }
+
+    @Override
+    public void run() {
+      pc.doCloseConnection(logErrors);
+    }
+
+    @Override
+    public String toString() {
+      return pc.toString();
+    }
+  }
+
+  /**
+   * Tries to close the pc in an async thread. The method waits up to 5 seconds and returns true,
+   * if connection was closed in this time.
+   * <p>
+   * If the connection could not be closed within 5 seconds,
+   */
+  void closeConnectionFullyAsync(PooledConnection pc, boolean logErrors) {
     executorLock.lock();
     try {
       if (executor != null) {
-        executor.submit(runable);
+        executor.submit(new AsyncCloser(pc, logErrors));
         return;
       }
     } finally {
       executorLock.unlock();
     }
     // it is possible, that we receive runnables after shutdown.
     // in this case, we will execute them immediately (outside lock)
-    runable.run();
+    pc.doCloseConnection(logErrors);
   }
 
   private void startExecutor() {
@@ -764,6 +792,13 @@ private void stopExecutor() {
     try {
       if (executor != null) {
         executor.shutdown();
+        try {
+          if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
+            Log.warn("DataSource [{0}] could not terminate executor.", name);
+          }
+        } catch (InterruptedException ie) {
+          Log.warn("DataSource [{0}] could not terminate executor.", name, ie);
+        }
         executor = null;
       }
     } finally {

ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java

@@ -239,13 +239,13 @@ void closeConnectionFully(boolean logErrors) {
       return; // this can happen in tests only.
     }
     pool.pstmtCacheMetrics(pstmtCache);
-    pool.execute(() -> doCloseConnection(logErrors));
+    pool.closeConnectionFullyAsync(this, logErrors);
   }
 
   /**
    * this mehthod performs network IO and may block
    */
-  private void doCloseConnection(boolean logErrors) {
+  void doCloseConnection(boolean logErrors) {
     long start = System.nanoTime();
     try {
       try {

ebean-datasource/src/test/java/io/ebean/datasource/pool/ConnectionPoolHangUpTest.java

@@ -0,0 +1,46 @@
+package io.ebean.datasource.pool;
+
+import io.ebean.datasource.DataSourceBuilder;
+import io.ebean.datasource.DataSourcePool;
+import org.h2.jdbc.JdbcConnection;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+import java.sql.Connection;
+
+public class ConnectionPoolHangUpTest {
+
+  @Test
+  @Disabled("run manually")
+  void testHoldLockOnObject() throws Exception {
+    DataSourcePool pool = DataSourceBuilder.create()
+      .url("jdbc:h2:mem:testConnectionPoolHangUp")
+      .username("sa")
+      .password("sa")
+      .heartbeatFreqSecs(1)
+      .minConnections(1)
+      .maxConnections(1)
+      .trimPoolFreqSecs(1)
+      .heartbeatMaxPoolExhaustedCount(0)
+      .failOnStart(false)
+      .build();
+    try {
+      Connection conn = pool.getConnection();
+      Thread t = new Thread(() -> {
+        try {
+          JdbcConnection h2Conn = conn.unwrap(JdbcConnection.class);
+          synchronized (h2Conn) {
+            Thread.sleep(300000);
+          }
+        } catch (Exception e) {
+          // nop
+        }
+      });
+      t.setDaemon(true);
+      t.start();
+    } finally {
+      pool.shutdown();
+    }
+  }
+
+}