Java 模擬數據庫連接池的實現代碼

更新時間：2021年02月25日 08:31:58 作者：低吟不作語

這篇文章主要介紹了Java 模擬數據庫連接池的實現,本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下

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

由于 java.sql.Connection 只是一個接口，最終實現是由數據庫驅動提供方來實現，考慮到本例只是演示，我們通過動態(tài)代理構造一個 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;
    }
  }

  /**
   * 創(chuàng)建一個 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
          // 分別統(tǒng)計獲取連接的數量 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 時，得出結果如下