Java：HikariDataSource对象的一致性

Question

我有一个类，看起来像这样：

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

public class ConnectionPool {
    private HikariDataSource hds;
    private final String propertyFileName;

    public ConnectionPool(String propertyFileName) {
        if (propertyFileName == null) {
            throw new IllegalArgumentException("propertyFileName can't be null");
        }

        this.propertyFileName = propertyFileName;
        reloadFile();
    }

    public void reloadFile() {
        if (hds != null) {
            hds.close();
        }

        hds = new HikariDataSource(new HikariConfig(propertyFileName));
    }

    public HikariDataSource getHikariDataSource() {
        return hds;
    }

    public String getPropertyFileName() {
        return propertyFileName;
    }

    public void executeQuery(final String sql, final CallBack<ResultSet, SQLException> callBack) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Connection connection = null;
                PreparedStatement preparedStatement = null;
                ResultSet resultSet = null;

                try {
                    connection = hds.getConnection();
                    preparedStatement = connection.prepareStatement(sql);
                    resultSet = preparedStatement.executeQuery();
                    callBack.call(resultSet, null);
                } catch (SQLException e) {
                    callBack.call(null, e);
                } finally {
                    if (resultSet != null) {
                        try {
                            resultSet.close();
                        } catch (SQLException ignored) {}
                    }

                    if (preparedStatement != null) {
                        try {
                            preparedStatement.close();
                        } catch (SQLException ignored) {}
                    }

                    if (connection != null) {
                        try {
                            connection.close();
                        } catch (SQLException ignored) {}
                    }
                }
            }
        }).start();
    }

    public void executeUpdate(final String sql, final CallBack<Integer, SQLException> callBack) {
        //TODO
    }

    public void execute(final String sql, final CallBack<Boolean, SQLException> callBack) {
        //TODO
    }

    public void connection(final String sql, final CallBack<Connection, SQLException> callBack) {
        //TODO
    }
}

问题是当使用hds时，可以从不同的线程调用reloadFile（）方法。所以当我在另一个线程中使用它的连接对象时，hds可能是关闭的。解决这个问题的最好办法是什么？在创建新的HikariDataSource对象之后，是否应该在关闭旧对象之前等待几秒钟（直到查询完成）？

编辑：另一个问题：hds是否应该是易失性的，以便hds的更改对所有线程都可见？

Answer 1

几个选项：

同步对数据源的所有访问，以便只有一个线程可以干扰它。不可扩展，但可行。

滚动您自己的连接池，例如ApacheCommons池，以便无论线程如何，每次访问都会请求一个数据源，并根据需要创建一个数据源。可能会弄乱数据，这取决于是否需要脏数据、何时刷新数据、事务性等。

每个线程还可以使用ThreadLocal拥有自己的数据源，以便每个线程彼此完全独立。同样，数据质量可能是一个问题，如果您有“很多”线程（取决于您的定义），那么资源可能是一个问题，并且太多打开的连接会导致客户机或服务器上的资源问题。

Answer 2

你到底为什么要让HikariCP重新加载？许多重要的池参数（最小化池、最大池大小、连接超时等）在运行时可以通过JMX bean进行控制，而无需重新启动池。

重新启动池是在连接关闭和重建时“挂起”应用程序几秒钟的好方法。如果你不能通过JMX接口做你需要的事情，阿德里安的建议似乎是一个相当合理的解决方案。

其他解决方案是可能的，但更为复杂。

编辑：只是为了我自己的娱乐，这里有一个更复杂的解决方案。。。

public class ConnectionPool {
   private AtomicReference<HikariDataSource> hds;

   public ConnectionPool(String propertyFileName) {
      hds = new AtomicReference<>();
      ...
   }

   public void reloadFile() {
      final HikariDataSource ds = hds.getAndSet(new HikariDataSource(new HikariConfig(propertyFileName)));
      if (ds != null) {
         new Thread(new Runnable() {
           public void run() {
              ObjectName poolName = new ObjectName("com.zaxxer.hikari:type=Pool (" + ds.getPoolName() + ")");
              MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
              HikariPoolMXBean poolProxy = JMX.newMXBeanProxy(mBeanServer, poolName, HikariPoolMXBean.class);

              poolProxy.softEvictConnections();
              do {
                 Thread.sleep(500);
              } while (poolProxy.getActiveConnections() > 0);
              ds.close();
           }
         }).start();
       }
   }

   public HikariDataSource getHikariDataSource() {
      return hds.get();
   }

   public void executeQuery(final String sql, final CallBack<ResultSet, SQLException> callBack) {
      new Thread(new Runnable() {
         @Override
         public void run() {
            ...
            try {
               connection = getHikariDataSource().getConnection();
               ...
            }
         }
      }).start();
   }
}

这将（原子地）交换池，并启动一个线程，在关闭孤立池实例之前等待所有活动连接返回。

这假设您允许HikariCP生成唯一的池名称，即不在属性中设置poolName，并且registerMbeans=true。

Answer 3

有一个非常非常快速和简短的查看源代码中的HikariDataSource。在其off（）中，它调用其内部Hikaripool的Shutdown（）方法，为此它将尝试正确关闭池连接。

如果您甚至想避免强制关闭正在进行的连接，一种方法是使用ReadWriteLock：

public class ConnectionPool {
    private HikariDataSource hds;
    private ReentrantReadWriteLock dsLock = ....;
    //....

    public void reloadFile() {
        dsLock.writeLock().lock();
        try {
            if (hds != null) {
                hds.close();
            }

            hds = new HikariDataSource(new HikariConfig(propertyFileName));
        } finally {
            dsLock.writeLock().unlock();
        }
    }

    public void executeQuery(final String sql, final CallBack<ResultSet, SQLException> callBack) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Connection connection = null;
                PreparedStatement preparedStatement = null;
                ResultSet resultSet = null;

                dsLock.readLock().lock();
                try {
                    connection = hds.getConnection();
                    // ....
                } catch (SQLException e) {
                    callBack.call(null, e);
                } finally {
                    // your other cleanups
                    dsLock.readLock().unlock();
                }
            }
        }).start();
    }
    //....
}

这将确保

1. 多个线程可以访问你的数据源（获得连接等）
2. 重装数据源需要等待，直到线程使用数据源完成
3. 没有线程能够使用数据源在重新加载时获得连接。