ConnectionBuffer maintains free and busy connections as LinkedList now

Author: rPraml

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

@@ -5,15 +5,22 @@
 /**
  * A buffer designed especially to hold pooled connections (free and busy ones)
  * <p>
+ * The buffer contains two linkedLists (free and busy connection nodes)
+ * <p>
+ * When a node from the free list is removed, the node is attached to the
+ * PooledConnection, so that the node object can be reused. This avoids object
+ * creation/gc during remove operations.
+ * <p>
  * All thread safety controlled externally (by PooledConnectionQueue).
  * </p>
  */
 final class ConnectionBuffer {
 
-
   private final Node free = Node.init();
+  private final Node busy = Node.init();
 
   int freeSize = 0;
+  int busySize = 0;
 
   /**
    * Return the number of entries in the buffer.
@@ -22,6 +29,13 @@ int freeSize() {
     return freeSize;
   }
 
+  /**
+   * Return the number of busy connections.
+   */
+  int busySize() {
+    return busySize;
+  }
+
   /**
    * Return true if the buffer is empty.
    */
@@ -30,28 +44,74 @@ boolean hasFreeConnections() {
   }
 
   /**
-   * Add connection to the free list.
+   * Adds a new connection to the free list.
    */
   void addFree(PooledConnection pc) {
+    assert pc.busyNode() == null : "Connection seems not to be new";
     new Node(pc).addAfter(free);
     freeSize++;
   }
 
+  /**
+   * Removes the connection from the busy list. (For full close)
+   * Returns true, if this connection was part of the busy list or false, if not (or removed twice)
+   */
+  boolean removeBusy(PooledConnection c) {
+    if (c.busyNode() == null) {
+      return false;
+    }
+    c.busyNode().remove();
+    busySize--;
+    c.setBusyNode(null);
+    return true;
+  }
+
+  /**
+   * Moves the connection from the busy list to the free list.
+   */
+  boolean moveToFreeList(PooledConnection c) {
+    Node node = c.busyNode();
+    if (node == null) {
+      return false;
+    }
+    node.remove();
+    busySize--;
+    node.addAfter(free);
+    freeSize++;
+    c.setBusyNode(null);
+    return true;
+  }
+
   /**
    * Remove a connection from the free list. Returns <code>null</code> if there is not any.
    */
-  PooledConnection popFree () {
+  PooledConnection popFree() {
     Node node = free.next;
     if (node.isBoundaryNode()) {
       return null;
     }
     node.remove();
     freeSize--;
+    node.pc.setBusyNode(node); // sets the node for reuse in "addBusy"
     return node.pc;
   }
 
   /**
-   * Close all connections in the free list.
+   * Adds the connection to the busy list. The connection must be either new or popped from the free list.
+   */
+  int addBusy(PooledConnection c) {
+    Node node = c.busyNode(); // we try to reuse the node to avoid object creation.
+    if (node == null) {
+      node = new Node(c);
+      c.setBusyNode(node);
+    }
+    node.addAfter(busy);
+    busySize++;
+    return busySize;
+  }
+
+  /**
+   * Close all free connections in this buffer.
    */
   void closeAllFree(boolean logErrors) {
     List<PooledConnection> tempList = new ArrayList<>();
@@ -92,6 +152,56 @@ int trim(int minSize, long usedSince, long createdSince) {
     return trimCount;
   }
 
+  void closeBusyConnections(long leakTimeMinutes) {
+    long olderThanTime = System.currentTimeMillis() - (leakTimeMinutes * 60000);
+    Log.debug("Closing busy connections using leakTimeMinutes {0}", leakTimeMinutes);
+    Node node = busy.next;
+    while (!node.isBoundaryNode()) {
+      Node current = node;
+      node = node.next;
+
+      PooledConnection pc = current.pc;
+      //noinspection StatementWithEmptyBody
+      if (pc.lastUsedTime() > olderThanTime) {
+        // PooledConnection has been used recently or
+        // expected to be longRunning so not closing...
+      } else {
+        current.remove();
+        --busySize;
+        closeBusyConnection(pc);
+      }
+    }
+  }
+
+  private void closeBusyConnection(PooledConnection pc) {
+    try {
+      Log.warn("DataSource closing busy connection? {0}", pc.fullDescription());
+      System.out.println("CLOSING busy connection: " + pc.fullDescription());
+      pc.closeConnectionFully(false);
+    } catch (Exception ex) {
+      Log.error("Error when closing potentially leaked connection " + pc.description(), ex);
+    }
+  }
+
+  String busyConnectionInformation(boolean toLogger) {
+    if (toLogger) {
+      Log.info("Dumping [{0}] busy connections: (Use datasource.xxx.capturestacktrace=true  ... to get stackTraces)", busySize());
+    }
+    StringBuilder sb = new StringBuilder();
+    Node node = busy.next;
+    while (!node.isBoundaryNode()) {
+      PooledConnection pc = node.pc;
+      node = node.next;
+      if (toLogger) {
+        Log.info("Busy Connection - {0}", pc.fullDescription());
+      } else {
+        sb.append(pc.fullDescription()).append("\r\n");
+      }
+    }
+    return sb.toString();
+  }
+
+
   /**
    * Node of a linkedlist. The linkedLists always have two empty nodes at the start and end.
    * (boundary nodes) They are generated with the init() method.

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

@@ -1,6 +1,13 @@
 package io.ebean.datasource.pool;
 
-import java.sql.*;
+import java.sql.CallableStatement;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.Savepoint;
+import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.Map;
 import java.util.concurrent.locks.ReentrantLock;
@@ -135,7 +142,7 @@ final class PooledConnection extends ConnectionDelegator {
   /**
    * Slot position in the BusyConnectionBuffer.
    */
-  private int slotId;
+  private ConnectionBuffer.Node busyNode;
 
 
   /**
@@ -184,17 +191,17 @@ final class PooledConnection extends ConnectionDelegator {
   }
 
   /**
-   * Return the slot position in the busy buffer.
+   * Return the node in the busy list. If this is empty, the connection is free
    */
-  int slotId() {
-    return slotId;
+  ConnectionBuffer.Node busyNode() {
+    return busyNode;
   }
 
   /**
-   * Set the slot position in the busy buffer.
+   * Set the busy node.
    */
-  void setSlotId(int slotId) {
-    this.slotId = slotId;
+  void setBusyNode(ConnectionBuffer.Node busyNode) {
+    this.busyNode = busyNode;
   }
 
   /**