用JAVA实现无等待数据库连接池

我们都知道数据库连接是一种有限和非常昂贵的应用资源，怎样对这些资源进行高效的管理，能有效的改善整个系统的性能和健壮性。数据库连接池正是针对这个问题而提出来的。

       数据库连接负责分配、释放和管理数据库连接。使数据库连接可以重复利用，而不是用一次建立一次数据库连接。



基本思路

       建立一个容器

每次到这个容器里得到连接，如果为空则建立一个新连接。

当连接使用完后归还给这个容器



这里就有二个难点

1．  容器必需是同步的，线程安全的。

2．  连接怎归还连接池



方案:

      针对这二个难点，我们分别提出了二个解决方法

1.使用ConcurrentLinkedQueue实现先进先出队列

ConcurrentLinkedQueue无界线程安全队列介绍

这个类在java.util.concurrent包中，我们来看看官方是怎描述这个类的
一个基于链接节点的无界线程安全队列。此队列按照 FIFO（先进先出）原则对元素进行排序。队列的头部 是队列中时间最长的元素。队列的尾部 是队列中时间最短的元素。新的元素插入到队列的尾部，队列获取操作从队列头部获得元素。当多个线程共享访问一个公共 collection 时，ConcurrentLinkedQueue 是一个恰当的选择。此队列不允许使用 null 元素.此实现采用了有效的“无等待 (wait-free)”算法

2.动态代理实现连接归还连接池

       大家也可以参考刘冬在IBM发表的文章

http://www.ibm.com/developerworks/cn/java/l-connpoolproxy/




接下来我们来看看整体代码



import java.io.PrintWriter;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.sql.Connection;

import java.sql.Driver;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import java.util.Properties;

import java.util.concurrent.ConcurrentLinkedQueue;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicLong;

import java.util.concurrent.locks.ReentrantLock;



import javax.sql.DataSource;



public class JavaGGDataSource implements DataSource {

    //连接队列

    private ConcurrentLinkedQueue<_Connection> connQueue = new ConcurrentLinkedQueue<_Connection>();

    //存放所有连接容器

    private List<_Connection> conns = new ArrayList<_Connection>();

    private Driver driver = null;



    private String jdbcUrl = null;

    private String user = null;

    private String password = null;

    private int maxActive = -1;// -1为不限制连接数

    private String driverClass = null;

    private int timeout = 1000 * 60 * 60 * 4;// 默认为4小时,即4小时没有任何sql操作就把所有连接重新建立连接

    private AtomicLong lastCheckout = new AtomicLong(System.currentTimeMillis());

    private AtomicInteger connCount = new AtomicInteger();

    //线程锁,主要用于新建连接和清空连接时

    private ReentrantLock lock = new ReentrantLock();



    public void closeAllConnection() {

    }



    /**

     * 归还连接给连接池

     *

     * @param conn

     *@date 2009-8-13

     *@author eric.chan

     */

    public void offerConnection(_Connection conn) {

       connQueue.offer(conn);

    }



    @Override

    public Connection getConnection() throws SQLException {

       return getConnection(user, password);

    }



    /**

     * 从池中得到连接，如果池中没有连接，则建立新的sql连接

     *

     * @param username

     * @param password

     * @author eric.chan

     */

    @Override

    public Connection getConnection(String username, String password)

           throws SQLException {

       checkTimeout();

       _Connection conn = connQueue.poll();

       if (conn == null) {

           if (maxActive > 0 && connCount.get() >= maxActive) {

              for (;;) {// 采用自旋方法 从已满的池中得到一个连接

                  conn = connQueue.poll();

                  if (conn != null)

                     break;

                  else

                     continue;

              }

           }

           lock.lock();

           try {

              if (maxActive > 0 && connCount.get() >= maxActive) {

                  // 处理并发问题

                  return getConnection(username, password);

              }

              Properties info = new Properties();

              info.put("user", username);

              info.put("password", password);

              Connection conn1 = loadDriver().connect(jdbcUrl, info);

              conn = new _Connection(conn1, this);

              int c = connCount.incrementAndGet();// 当前连接数加1

              conns.add(conn);

              System.out.println("info : init no. " + c + " connectioned");

           } finally {

              lock.unlock();

           }

       }

       lastCheckout.getAndSet(System.currentTimeMillis());

       return conn.getConnection();

    }



    /**

     * 检查最后一次的连接时间

     *

     * @throws SQLException

     *@date 2009-8-13

     *@author eric.chan

     */

    private void checkTimeout() throws SQLException {

       long now = System.currentTimeMillis();

       long lt = lastCheckout.get();

       if ((now - lt) > timeout) {

           _Connection conn = null;

           lock.lock();

           try {

              if(connCount.get()==0)return;

              while ((conn = connQueue.poll()) != null) {

                  System.out.println("connection " + conn + " close ");

                  conn.close();

                  conn = null;

              }

              for(_Connection con:conns){

                  con.close();

              }

              conns.clear();

              System.out.println("info : reset all connections");

              connCount.getAndSet(0);// 重置连接数计数器

              lastCheckout.getAndSet(System.currentTimeMillis());

           } finally {

              lock.unlock();

           }

       }

    }



    /**

     *

     * @return

     *@date 2009-8-13

     *@author eric.chan

     */

    private Driver loadDriver() {

       if (driver == null) {

           try {

              driver = (Driver) Class.forName(driverClass).newInstance();

           } catch (ClassNotFoundException e) {

              System.out.println("error : can not find driver class " + driverClass);

           } catch (Exception e) {

              e.printStackTrace();

           }

       }

       return driver;

    }



    @Override

    public PrintWriter getLogWriter() throws SQLException {

       return null;

    }



    @Override

    public int getLoginTimeout() throws SQLException {

       return 0;

    }



    @Override

    public void setLogWriter(PrintWriter out) throws SQLException {

    }



    @Override

    public void setLoginTimeout(int seconds) throws SQLException {

    }



    @Override

    public boolean isWrapperFor(Class iface) throws SQLException {

       throw new SQLException("no Implemented isWrapperFor method");

    }



    @Override

    public T unwrap(Class iface) throws SQLException {

       throw new SQLException("no Implemented unwrap method");

    }



    public String getJdbcUrl() {

       return jdbcUrl;

    }



    public void setJdbcUrl(String jdbcUrl) {

       this.jdbcUrl = jdbcUrl;

    }



    public String getUsername() {

       return user;

    }



    public void setUsername(String user) {

       this.user = user;

    }



    public String getPassword() {

       return password;

    }



    public void setPassword(String password) {

       this.password = password;

    }



    public String getDriverClass() {

       return driverClass;

    }



    public void setDriverClass(String driverClass) {

       this.driverClass = driverClass;

    }



    public int getTimeout() {

       return timeout;

    }



    public void setTimeout(int timeout) {

       this.timeout = timeout * 1000;

    }



    public void setMaxActive(int maxActive) {

       this.maxActive = maxActive;

    }



    public int getMaxActive() {

       return maxActive;

    }

}



/**

* 数据连接的自封装 ,是java.sql.Connection的一个钩子,主要是处理close方法

*

* @author eric

*

*/

class _Connection implements InvocationHandler {

    private final static String CLOSE_METHOD_NAME = "close";



    private final Connection conn;

    private final JavaGGDataSource ds;



    _Connection(Connection conn, JavaGGDataSource ds) {

       this.conn = conn;

       this.ds = ds;

    }



    @Override

    public Object invoke(Object proxy, Method method, Object[] args)

           throws Throwable {

       Object obj = null;

       // 判断是否调用了close的方法，如果调用close方法则把连接置为无用状态

       if (CLOSE_METHOD_NAME.equals(method.getName())) {

           // 归还连接给连接池

           ds.offerConnection(this);

       } else {

           // 运行非close的方法

           obj = method.invoke(conn, args);

       }

       return obj;

    }



    public Connection getConnection() {

       // 返回数据库连接conn的接管类，以便截住close方法

       Connection conn2 = (Connection) Proxy.newProxyInstance(conn.getClass().getClassLoader(), new Class[] { Connection.class }, this);

       return conn2;

    }



    public void close() throws SQLException {

       // 调用真正的close方法,一但调用此方法就直接关闭连接

       if(conn!=null&&!conn.isClosed())

       conn.close();

    }



}





_Connection类是一个私有类，主要实现一个对Connection动态代理的功能(有点象windows的钩子)

说白了就是实现调用connection.close方法时我们映射到另一个方法上.

呵呵，是不是好简单呢，代码没有多复杂。

这里有一个问题要说明一吓：如果设置的maxActive值小于当前线程总数，那么当并发非常大时会出现资源争夺情况，一吓子cpu就会提高不小，所以建议设为无限制，或大于线程总数的值。



接下来我们测试测试

开五十个线程，对同一个表进行select/insert 10000次操作，每次select/insert一条记录

代码如下：

public static void main(String[] args) {

       JavaGGDataSource ds = new JavaGGDataSource();

            ds.setDriverClass("com.mysql.jdbc.Driver");

            ds.setJdbcUrl("jdbc:mysql://192.168.1.6:3306/test");

            ds.setPassword("ps");

            ds.setUsername("name");

            ds.setTimeout(300);

            // ds.setMaxActive(60);

            for (int i = 0; i < 50; i++) {

            new GG(ds).start();

            }

}

class GG extends Thread {

    JavaGGDataSource ds = null;

    long l = System.currentTimeMillis();



    public GG(JavaGGDataSource ds) {

       this.ds = ds;

    }

static String sql = "insert into testgg(col1,cols) values (?,?)";

    static String selectsql = "select * from testgg where id=?";



public void run() {

       for (int t = 0; t < 10000; t++) {

           Connection conn = null;

           try {

              conn = ds.getConnection();

               PreparedStatement ps = conn.prepareStatement(sql);

              //以下为insert

              ps.setInt(1, 133664);

              ps.setString(2, "ddd");

              ps.executeUpdate();

              //以下为select

              ResultSet rs=ps.executeQuery();

              while(rs.next()){

              rs.getInt("id");

              rs.getInt("col1");

              }

              rs.close();

              ps.close();

           } catch (SQLException e) {

              // TODO Auto-generated catch block

              e.printStackTrace();

           } finally {

              try {

                  if (conn != null) {

//                   ds.offerConnection(conn);

                     conn.close();

                  }

               } catch (Exception e) {

                  e.printStackTrace();

              }

           }

       }

       System.out.println(System.currentTimeMillis() - l);

   }



测试结果

50个线程select 10000*50次结果

Javaggds  406à2156毫秒    连接池有50个连接(和线程数一样)

C3p0              1235à1657毫秒   连接池有500个连接(和设置的最大连接数一样 )

50个线程insert 10000*50次结果

Javaggds  39125à52734  连接池有50个连接(和线程数一样)

C3p0           60000à65141毫秒  连接池有500个连接(和设置的最大连接数一样 )



测试分析：

c3p0是使用同锁或同步块对连接池进行同步的，所以它的时间会控制在一定范围之内

但带来的问题是线程竞争和线程等待。

Javaggds是使用了concurrent包中的无等待算法队列，这个同步是在cpu层面上做的，所以同步的块非常小，大家有兴趣可以看看CAS同步算法。



Hibernate结合

       编辑hibernate 加入/修改配置为

<property name="connection.provider_class">

           com.javagg.datasource.DataSourceConnectionProvider<property>

       <property name="db.driverClass">com.mysql.jdbc.Driver<property>

       <property name="db.jdbcUrl">jdbc:mysql://192.168.1.6:3306/test<property>

       <property name="db.username">name<property>

       <property name="db.password">password<property>



       <property name="db.datasource">

           com.javagg.datasource.JavaGGDataSource<property>

       <property name="db.maxActive">-1<property>< 无限制连接数 >

       <property name="db.timeout">3600<property>< 一小时timeout 单位为秒 >



DataSourceConnectonProvider代码如下：



import java.lang.reflect.Method;

import java.sql.Connection;

import java.sql.SQLException;

import java.util.Iterator;

import java.util.Properties;



import javax.sql.DataSource;



import org.apache.commons.beanutils.BeanUtils;

import org.hibernate.HibernateException;

import org.hibernate.connection.ConnectionProvider;



public class DataSourceConnectionProvider implements ConnectionProvider {



    private final static String BASE_KEY = "db.";

    private final static String DATASOURCE_KEY = "db.datasource";



    protected DataSource dataSource;



    /*

     * (non-Javadoc)

     *

     * @see

     * org.hibernate.connection.ConnectionProvider#configure(java.util.Properties

     * )

     */

    public void configure(Properties props) throws HibernateException {

       initDataSource(props);

    }



    /*

     * (non-Javadoc)

     *

     * @see org.hibernate.connection.ConnectionProvider#getConnection()

     */

    public Connection getConnection() throws SQLException {

       return dataSource.getConnection();

    }



    /*

     * (non-Javadoc)

     *

     * @see

     * org.hibernate.connection.ConnectionProvider#closeConnection(java.sql.

     * Connection)

     */

    public void closeConnection(Connection conn) throws SQLException {

       if (conn != null)

           conn.close();

    }



    /*

     * (non-Javadoc)

     *

     * @see org.hibernate.connection.ConnectionProvider#close()

     */

    public void close() throws HibernateException {

       if (dataSource != null)

           try {

              Method mClose = dataSource.getClass().getMethod("close");

              mClose.invoke(dataSource);

           } catch (Exception e) {

              throw new HibernateException(e);

           }

       dataSource = null;

    }



    /*

     * (non-Javadoc)

     *

     * @see

     * org.hibernate.connection.ConnectionProvider#supportsAggressiveRelease()

     */

    public boolean supportsAggressiveRelease() {

       return false;

    }



    /**

     * Initialize the datasource

     *

     * @param props

     * @throws HibernateException

     */

    protected void initDataSource(Properties props) throws HibernateException {

       String dataSourceClass = null;

       Properties new_props = new Properties();

       Iterator keys = props.keySet().iterator();

       while (keys.hasNext()) {

           String key = (String) keys.next();

           if (key.equals(DATASOURCE_KEY)) {

              dataSourceClass=props.getProperty(key);

           } else if (key.startsWith(BASE_KEY)) {

              String value = props.getProperty(key);

              new_props.setProperty(key.substring(BASE_KEY.length()), value);

           }

       }

       if (dataSourceClass == null)

           throw new HibernateException("Property 'db.datasource' no defined.");

       try {

           dataSource = (DataSource) Class.forName(dataSourceClass).newInstance();

           BeanUtils.populate(dataSource, new_props);

       } catch (Exception e) {

           throw new HibernateException(e);

       }

    }



}



接下来我们测试配置有没有成功

代码如下：

public static void main(String args[]) {

       Configuration cfg = new Configuration();

       cfg.configure();

       SessionFactory sf = cfg.buildSessionFactory();

       for (int i = 0; i < 100; i++) {

           Session sess = sf.openSession();



           TestGGBean pc = new TestGGBean();

           pc.setCol1(1111);

           pc.setCols("ddaaaa");

           sess.save(pc);

           sess.flush();

           sess.close();

       }

    }