数据库连接池-高并发处理

上一篇构建的数据库连接池,今天拿来在项目中测试时,发现在处理高并发的问题上有很明显的缺点。

现在回过头来看我们上一篇的代码:

public class ConnectionPool {  
    
    /*线程安全数组*/
    private volatile Vector<Connection> pool;  
    private volatile Connection selectConnection;
    /*公有属性*/  
    private String url = "jdbc:mysql://127.0.0.1/text";  
    private String username = "root";  
    private String password = "root";  
    private String driverClassName = "com.mysql.jdbc.Driver";  
    /*连接池中储存的最大数量*/
    private final int poolSize = 10;  
    /*当线程池耗尽时,最大新建数量*/
    private final int newPoolSize = 10;
    private volatile static int tab = 0;
    private static ConnectionPool instance = null;  
    private Connection conn = null; 
    private static ConnectionPool mConnectionPool = null;
    
    public static ConnectionPool getInstance() throws SQLException{
        synchronized (Connection.class) {
            if (mConnectionPool == null){
                mConnectionPool = new ConnectionPool();
                return mConnectionPool;
            }
            return mConnectionPool;
        }
    }
  
    /*构造方法,做一些初始化工作*/  
    private ConnectionPool() throws SQLException { 
        pool = new Vector<Connection>(poolSize);  
        selectConnection = DriverManager.getConnection(url, username, password);
        try { 
        for (int i = 0; i < poolSize; i++) {  
                conn = DriverManager.getConnection(url, username, password);  
                pool.add(conn);  
                }  
        } catch (SQLException e) {  
            e.printStackTrace();  
        }  
    }  
    
    /*得到select使用的连接,查询不同于其他三项,查询可以并发进行执行,
     * 所以我们只需提供一个连接来供所有用户使用*/
    public Connection getSelectConnection() throws SQLException{
        if(selectConnection != null){
            return selectConnection;
        }
        synchronized (ConnectionPool.class) {
            if(selectConnection == null){
                selectConnection = DriverManager.getConnection(url, username, password);
            }
        }
        return selectConnection;
    }
  
    /* 返回连接到连接池
     * 在这里进行控制,如果连接池里的连接数大于我们规定的数量,则对此连接进行关闭
     */
    public synchronized void release(Connection con) throws SQLException {
        if(con == null){
            return;
        }
        if (pool.size() >= poolSize){
            tab-=1;
            con.close();
            return;
        } 
        pool.add(con);  
    }  
  
    /* 返回连接池中的一个数据库连接
     * 如果连接池中已经耗尽了Connextion
     * 则创建新的使用 
     */
    public Connection getConnection() {  
        synchronized(ConnectionPool.class){
            if (pool.size() > 0) {  
                Connection conn = pool.get(0);
                pool.remove(conn);  
                System.out.println("得到连接");
                return conn;  
            }
            if(tab < newPoolSize){
                System.out.println("得到新建的连接");
                return newConnection(); 
            } 
        }
        /*如果连接池耗尽,并且新建连接也到最大值,那么在这里排队等待*/
        synchronized (ConnectionPool.class) {
            try {
                while(pool.size() == 0){                
                    Thread.sleep(1*50);
                }
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            Connection conn = pool.get(0);  
            pool.remove(conn); 
            System.out.println("得到回收之后重新利用的连接");
            return conn;
        }
    }  
    
    /*新建连接*/
    private Connection newConnection(){
        try {  
            tab+=1;
            Connection conn = DriverManager.getConnection(url, username, password);  
            pool.add(conn); 
            return conn;
        } catch (SQLException e) {   
            return null; 
        }   
    }
}  

问题一:我们在release方法和getConnection方法都使用了synchronized,而且我们使用的都是一个对象ConnectionPool.class,意思就是说,当getConnection的对象锁被一个用户拿到,导致其他的用户无法执行release方法!

问题二:当第一个线程进入getConnection方法或者release方法,后面的用户就必须排队,所以在这方面我们需要进行优化,其实这个问题解决的空间还是很大的。

建议:
  1、尽量使用tryLock(long timeout, TimeUnit unit)的方法(ReentrantLock、ReentrantReadWriteLock),设置超时时间,超时可以退出防止死锁。
  2、尽量使用java.util.concurrent包的并发类代替手写控制并发,比较常用的是ConcurrentHashMap、ConcurrentLinkedQueue、AtomicBoolean等等,实际应用中java.util.concurrent.atomic十分有用,简单方便且效率比使用Lock更高 。
  3、尽量不要几个功能用同一把锁 。
  4、尽量减少同步的代码块。

ok,下面是我优化过得代码,使用ReentrantLock替换掉了一部分synchronized,确保发生死锁时会自动跳出,不至于程序的崩溃。

public class ConnectionPool {  
    
    /*线程安全数组*/
    private volatile Vector<Connection> pool;  
    private volatile Vector<Connection> recordPool;
    private volatile Connection selectConnection;
    /*公有属性*/  
    private String url = "jdbc:mysql://127.0.0.1/one?useSSL=true";  
    private String username = "root";  
    private String password = "root";  
    private String driverClassName = "com.mysql.jdbc.Driver";  
    /*连接池中储存的最大数量*/
    private final int poolSize = 10;  
    /*当线程池耗尽时,最大新建数量*/
    private final int newPoolSize = 80;
    private static ConnectionPool instance = null;  
    private Connection conn = null; 
    private static ConnectionPool mConnectionPool = null;
 
    /**
     * 这里定义三组顶层父类,没一个父类对象控制一把锁,他们意义在与多个锁的互不排斥。
     */
    private Object obj3 = new Object();
    private Object obj4 = new Object();
    private Object obj5 = new Object();
    /*不同于synchronized的另一种锁机制*/
    private Lock lock = new ReentrantLock();
    private Lock lock2 = new ReentrantLock();
    private Lock lock3 = new ReentrantLock();
    private Lock lock4 = new ReentrantLock();
    
    public static ConnectionPool getInstance() throws SQLException, ClassNotFoundException{
        if(mConnectionPool != null){
            return mConnectionPool;
        }
        synchronized (ConnectionPool.class) {
            if (mConnectionPool == null){
                mConnectionPool = new ConnectionPool();
            }
            return mConnectionPool;
        }
    }
  
    /*构造方法,做一些初始化工作*/  
    private ConnectionPool() throws SQLException, ClassNotFoundException { 
        System.out.println("初始化开始");
        pool = new Vector<Connection>();  
        recordPool = new Vector<Connection>();
        selectConnection = load();
        for (int i = 0; i < poolSize; i++) {  
                conn = load();  
                pool.add(conn);  
        }  
        System.out.println("初始化结束");  
    }  
    
    /*得到select使用的连接,查询不同于其他三项,查询可以并发进行执行,
     * 所以我们只需提供一个连接来供所有用户使用*/
    public Connection getSelectConnection() throws SQLException, InterruptedException{
        if(selectConnection != null && !selectConnection.isClosed()){
            return selectConnection;
        }
        if(lock2.tryLock(8L,TimeUnit.SECONDS)){
            if(selectConnection == null || selectConnection.isClosed()){
                selectConnection = load();
            }
            lock2.unlock();
        }
        return selectConnection;
    }
  
    /* 返回连接到连接池
     * 在这里进行控制,如果连接池里的连接数大于我们规定的数量,则对此连接进行关闭
     */
    public void release(Connection con) throws SQLException, InterruptedException {
        if(con == null || con.isClosed()){
            recordPool.remove(con);
            return;
        }
        if(lock3.tryLock(8L,TimeUnit.SECONDS)){
            if (pool.size() >= poolSize){
                con.close();
                lock3.unlock();
                return;
            }  
            if(pool.size() < poolSize){
                pool.add(con); 
            }
            lock3.unlock();
        }
    }  
    
    private Connection getNewConnection(){
        /*考虑到多线程访问,防止当多名用户同时拿连接或回收时产生误差,在这里进行双层判断*/
        if(recordPool.size() < newPoolSize){
            
                    if(pool.size() > 0){
                        return pool.remove(0);
                    }
                    if(recordPool.size() < newPoolSize){
                        Connection conn = load();
                        recordPool.add(conn);
                        System.out.println("得到新建的连接");
                        return conn;    
                    }
        }
        return null;
    }
  
    /* 返回连接池中的一个数据库连接
     * 如果连接池中已经耗尽了Connextion
     * 则创建新的使用 
     */
    public Connection getConnection() throws ClassNotFoundException, InterruptedException {  
            if (pool.size() > 0) {  
                synchronized (obj3) {
                    if(pool.size() > 0){
                        System.out.println("得到连接");
                        return pool.remove(0);
                    }
                }
            }
            if(lock4.tryLock(8L,TimeUnit.SECONDS)){
                Connection con = getNewConnection();
                lock4.unlock();
                if(con != null){
                    return con;
                }
            }
            /*如果连接池耗尽,并且新建连接也到最大值,那么在这里排队等待*/       
            try {
                synchronized (obj5) {
                    while(true){
                        System.out.println("进入等待");
                        Thread.sleep(1*50);
                        for (int i = 0; i < recordPool.size(); ) {
                            if (recordPool.get(i).isClosed() || recordPool.get(i)==null) {
                                recordPool.remove(i);
                            } else{
                                i++;
                            }
                        }
                        if(pool.size() != 0){
                            recordPool.add(pool.get(0));
                            return pool.remove(0);
                        }
                        if(recordPool.size() < newPoolSize){
                            Connection conn = load();
                            recordPool.add(conn);
                            return conn;
                        }
                    }
                }
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return null;
    }  
    
    /*拿到新建连接*/
    private Connection load(){
        try {
            Class.forName("com.mysql.jdbc.Driver");
            return DriverManager.getConnection(url, username, password);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }       
        return null;
    }
}  

结束。

笔者能力有限,不足之处欢迎指出。

    原文作者:麦兜叮叮当
    原文地址: https://www.jianshu.com/p/a5419af1dea8
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞