Java 模擬資料庫連接池的實作

前面學習過等待 - 通知機制，現在我們在其基礎上添加一個超時機制，模擬從連接池中獲取、使用和釋放連接的程序，客戶端獲取連接的程序被設定為等待超時模式，即如果在 1000 毫秒內無法獲取到可用連接，將會回傳給客戶端一個 null，設定連接池的大小為 10 個，然后通過調節客戶端的執行緒數來模擬無法獲取連接的場景

由于 java.sql.Connection 只是一個介面，最終實作是由資料庫驅動提供方來實作，考慮到本例只是演示，我們通過動態代理構造一個 Connection，該 Connection 的代理僅僅是在呼叫 commit() 方法時休眠 100 毫秒

public class ConnectionDriver {

    static class ConnectionHandler implements InvocationHandler {

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if ("commit".equals(method.getName())) {
                TimeUnit.MICROSECONDS.sleep(100);
            }
            return null;
        }
    }

    /**
     * 創建一個 Connection 的代理，在 commit 時休眠 100 毫秒
     */
    public static Connection createConnection() {
        return (Connection) Proxy.newProxyInstance(ConnectionDriver.class.getClassLoader(),
                new Class<?>[]{Connection.class}, new ConnectionHandler());
    }
}

接下來是執行緒池的實作，本例通過一個雙向佇列來維護連接，呼叫方需要先呼叫 fetchConnection(long) 方法來指定在多少毫秒內超時獲取連接，當連接使用完成后，需要呼叫 releaseConnection(Connection) 方法將連接放回執行緒池

public class ConnectionPool {

    private final LinkedList<Connection> pool = new LinkedList<>();

    public ConnectionPool(int initialSize) {
        // 初始化連接的最大上限
        if (initialSize > 0) {
            for (int i = 0; i < initialSize; i++) {
                pool.addLast(ConnectionDriver.createConnection());
            }
        }
    }

    public void releaseConnection(Connection connection) {
        if (connection != null) {
            synchronized (pool) {
                /* 連接釋放后需要進行通知
                 * 這樣其他消費者就能知道連接池已經歸還了一個連接
                 */
                pool.addLast(connection);
                pool.notifyAll();
            }
        }
    }

    /**
     * 在給定毫秒時間內獲取連接
     */
    public Connection fetchConnection(long mills) throws InterruptedException {
        synchronized (pool) {
            // 完全超時
            if (mills < 0) {
                while (pool.isEmpty()) {
                    pool.wait();
                }
                return pool.removeFirst();
            } else {
                long future = System.currentTimeMillis() + mills;
                long remaining = mills;
                while (pool.isEmpty() && remaining > 0) {
                    pool.wait(remaining);
                    remaining = future - System.currentTimeMillis();
                }
                Connection result = null;
                if (!pool.isEmpty()) {
                    result = pool.removeFirst();
                }
                return result;
            }
        }
    }
}

最后撰寫一個用于模擬客戶端獲取連接的示例，該示例將模擬多個執行緒同時從連接池獲取連接，并記錄總嘗試獲取數、獲取成功數和獲取失敗數

public class ConnectionPoolTest {

    static ConnectionPool pool = new ConnectionPool(10);
    static CountDownLatch start = new CountDownLatch(1);
    static CountDownLatch end;

    public static void main(String[] args) throws InterruptedException {
        // 執行緒數量
        int threadCount = 200;
        end = new CountDownLatch(threadCount);
        int count = 20;
        AtomicInteger got = new AtomicInteger();
        AtomicInteger notGot = new AtomicInteger();
        for (int i = 0; i < threadCount; i++) {
            Thread thread = new Thread(new ConnectionRunner(count, got, notGot), "ConnectionRunnerThread");
            thread.start();
        }
        start.countDown();
        end.await();
        System.out.println("total invoke : " + (threadCount * count));
        System.out.println("got connection : " + got);
        System.out.println("not got connection : " + notGot);
    }

    static class ConnectionRunner implements Runnable {

        int count;
        AtomicInteger got;
        AtomicInteger notGot;

        public ConnectionRunner(int count, AtomicInteger got, AtomicInteger notGot) {
            this.count = count;
            this.got = got;
            this.notGot = notGot;
        }

        @Override
        public void run() {
            try {
                start.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
            while (count > 0) {
                try {
                    // 從執行緒池中獲取連接，如果 1000ms 內無法獲取到，將回傳 null
                    // 分別統計獲取連接的數量 got 和未獲取到的數量 notGot
                    Connection connection = pool.fetchConnection(1000);
                    if (connection != null) {
                        try {
                            connection.createStatement();
                            connection.commit();
                        } finally {
                            pool.releaseConnection(connection);
                            got.incrementAndGet();
                        }
                    } else {
                        notGot.incrementAndGet();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    count--;
                }
            }
            end.countDown();
        }
    }
}

筆者設定執行緒數量為 200 時，得出結果如下

當設定為 500 時，得出結果如下，當然具體結果根據機器性能而異

可見，隨著客戶端執行緒數的增加，客戶端出現超時無法獲取連接的比率不斷升高，這種等待超時模式能保證程式出問題時，執行緒不會一直運行，而是按時回傳，并告知客戶端獲取連接出現問題，資料庫連接池的實際也可以應用到其他資源獲取的場景，針對昂貴資源的獲取都應該加以限制

標籤：其他

上一篇：spring(1)

下一篇：c++函式指標說明