Package com.aoindustries.io

Class AOPool<C extends AutoCloseable,​E extends Throwable,​I extends Throwable>

  • All Implemented Interfaces:
    Runnable
    public abstract class AOPool<C extends AutoCloseable,​E extends Throwable,​I extends Throwable>
extends Thread
    Reusable generic connection pooling with dynamic flaming tiger feature.

    Two lists of connections are maintained. The first is the list of connections that are ready unused, and the second is the list of connections that are currently checked-out. By using this strategy, an available connection can be found without searching the entire list.

    In addition to the global lists, a ThreadLocal list of connections checked-out by the current thread is maintained. When getting a new connection, this is used to check against maxConnections instead of checking the global lists.

    Idea: Add some sort of thread-connection affinity, where the same connection slot will be used by the same thread when it is available. This should help cache locality.

    Idea: Automatically connect ahead of time in the background. This could hide connection latency on first-use.

    Author:
    AO Industries, Inc.

    • Field Detail

      • UNLIMITED_MAX_CONNECTION_AGE

        public static final long UNLIMITED_MAX_CONNECTION_AGE
        See Also:
        Constant Field Values

      • DEFAULT_MAX_CONNECTION_AGE

        public static final long DEFAULT_MAX_CONNECTION_AGE
        See Also:
        Constant Field Values

      • DEFAULT_CONNECT_TIMEOUT

        public static final int DEFAULT_CONNECT_TIMEOUT
        See Also:
        Constant Field Values

      • DEFAULT_SOCKET_SO_LINGER

        public static final int DEFAULT_SOCKET_SO_LINGER
        See Also:
        Constant Field Values

      • logger

        protected final Logger logger
        All warnings are sent here if available, otherwise will be written to System.err.

    • Constructor Detail

      • AOPool

        protected AOPool​(String name,
                 int poolSize,
                 long maxConnectionAge,
                 Logger logger)

      • AOPool

        protected AOPool​(int delayTime,
                 int maxIdleTime,
                 String name,
                 int poolSize,
                 long maxConnectionAge,
                 Logger logger)

    • Method Detail

      • close

        protected abstract void close​(C conn)
                       throws E extends Throwable
        Closes the underlying connection. The connection may or may not already have been reset. The connection may or may not already be closed.

        Please note, this is distinct from the implementation of AutoCloseable for use in try-with-resources.

        Throws:
        E extends Throwable

      • close

        public final void close()
        Shuts down the pool, exceptions during close will be logged as a warning and not thrown.

      • getConcurrency

        public final int getConcurrency()
        Gets the number of connections that are currently busy.

      • getConnectionCount

        public final int getConnectionCount()
        Gets the number of connections currently connected.

      • getConnection

        public C getConnection()
                throws I extends Throwable,
                       E extends Throwable
        Gets either an available connection or creates a new connection, warning when a connection is already used by this thread.

        If all the connections in the pool are busy and the pool is at capacity, waits until a connection becomes available.

        Returns:
        Either a reused or new connection
        Throws:
        I - when interrupted
        E - when an error occurs, or when a thread attempts to allocate more than half the pool
        I extends Throwable
        See Also:
        getConnection(int), AutoCloseable.close()

      • getConnection

        public C getConnection​(int maxConnections)
                throws I extends Throwable,
                       E extends Throwable
        Gets either an available connection or creates a new connection.

        If all the connections in the pool are busy and the pool is at capacity, waits until a connection becomes available.

        Parameters:
        maxConnections - The maximum number of connections expected to be used by the current thread. This should normally be one to avoid potential deadlock.

        The connection will continue to be considered used by the allocating thread until released (via AutoCloseable.close(), even if the connection is shared by another thread.

        Returns:
        Either a reused or new connection
        Throws:
        I - when interrupted
        E - when an error occurs, or when a thread attempts to allocate more than half the pool
        I extends Throwable
        See Also:
        getConnection(), AutoCloseable.close()

      • getConnects

        public final long getConnects()
        Gets the total number of connects for the entire pool.

      • getMaxConnectionAge

        public final long getMaxConnectionAge()
        Gets the maximum age for connections.

      • getMaxConcurrency

        public final int getMaxConcurrency()
        Gets the maximum number of connections that have been busy at once.

      • getPoolSize

        public final int getPoolSize()
        Gets the maximum number of connections the pool will create at once.

      • getTotalTime

        public final long getTotalTime()

      • getTransactionCount

        public final long getTransactionCount()

      • isClosed

        protected abstract boolean isClosed​(C conn)
                             throws E extends Throwable
        Determine if the underlying connection is closed.

        Please note, this is distinct from the implementation of AutoCloseable for use in try-with-resources.

        Throws:
        E extends Throwable

      • printConnectionStats

        protected void printConnectionStats​(Appendable out,
                                    boolean isXhtml)
                             throws IOException
        Prints additional connection pool details. Must have opened the <tbody>.
        Throws:
        IOException

      • resetConnection

        protected abstract void resetConnection​(C conn)
                                 throws I extends Throwable,
                                        E extends Throwable
        Resets the given connection for release back to the pool.
        Throws:
        I extends Throwable

      • run

        public final void run()
        The RefreshConnection thread polls every connection in the connection pool. If it detects a connection is idle for more than the pre-defined MAX_IDLE_TIME, it closes the connection. It will stop when the pool is flagged as closed.
        Specified by:
        run in interface Runnable
        Overrides:
        run in class Thread

      • newException

        protected abstract E newException​(String message,
                                  Throwable cause)

      • newInterruptedException

        protected abstract I newInterruptedException​(String message,
                                             Throwable cause)

      • getLogger

        public final Logger getLogger()