池化技术原理，手写数据库连接池

其他 2020-01-15 11:21:17 阅读次数: 0

池化技术在后端开发中应用非常广泛，有数据库连接池，线程池，对象池，常量池等。池化技术的出现是为了提高性能。实际就是对一些使用率较高，且创建销毁比较耗时的资源进行缓存，避免重复地创建和销毁，做到资源回收利用。

传统的数据库连接池有DBCP，C3P0，目前新一代的连接池Druid、HikariaCP等较传统的数据库连接池在性能上有很大的提升。本文将手写一个简单功能的数据库连接池，以理解数据库连接池的基本原理和使用。

一、原生数据库访问方式所带来的问题

一般来说，java应用访问数据库有以下几步操作：

  • 装载数据库驱动，

    Class.forName(JDBC_DRIVER);

  • 通过jdbc建立数据库连接，

    DriverManager.getConnection(JDBC_URL, JDBC_USERNAME, JDBC_PASSWORD)

  • 访问数据库，执行sql语句

    String sql = "select email from user where id = 5";
PreparedStatement statement = conn.prepareStatement(sql);
ResultSet result = statement.executeQuery();
while (result.next()){
    String email = result.getString(1);
    System.out.println("【email】:"+email);
}

  • 断开数据库连接

    result.close(); state.close(); conn.close();

每一个请求过来都要建立数据库连接，连接数据库需要建立网络连接、系统要分配内存资源、使用完必须断开连接，这些过程可能比实际进行的数据库操作耗时好多倍。并且在高并发量的请求情况下，应用响应速度就会非常慢，甚至造成服务器崩溃。

由此可见，数据库连接是一种非常昂贵的资源。

二、数据库连接池技术

为解决上述问题，可以采用数据库连接池技术。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。初始化时在缓冲池中放入指定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。我们可以通过设定各种参数来控制初始连接数量、最大连接数量、最大空闲连接数量、等待时间等，还可以通过连接池的管理机制来监视数据库连接的数量和使用情况，方便开发测试和性能调优。

有了这些需求下面来实现一个简单的数据库连接池，实现连接池初始化方法、获取连接方法、回收连接方法、销毁池方法，以及几个参数的可配置。

1、工具类：MysqlConnectionUtils

首先将jdbc层面的代码封装成工具类，提供获取连接，关闭连接的方法，以Mysql为例，这部分代码不是重点，所以配置信息也直接写到类里面了：

public class MysqlConnectionUtils {
    public static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
    public static final String JDBC_URL = "jdbc:mysql://localhost:3306/usercase?useUnicode=true&characterEncoding=utf-8";
    public static final String JDBC_USERNAME = "root";
    public static final String JDBC_PASSWORD = "123456";
    public static Connection getConnection() {
        Connection connection=null;
        try {
            Class.forName(JDBC_DRIVER);
            connection = DriverManager.getConnection(JDBC_URL, JDBC_USERNAME, JDBC_PASSWORD);
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }
    public static void closeConnection(Connection conn){
        if (conn == null) {return;}
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
2、定义接口：ConnectionPool

定义接口：

public interface ConnectionPool {
    /*初始化*/
    void init(int initSize,int maxSize,int idleCount,long waitTime);
    /*获取连接*/
    Connection getConnection() throws TimeoutException;
    /*回收*/
    void recycle(Connection conn);
    /*销毁*/
    void destory();
}
3、实现类：MyConnectionPool

属性

这个就是我们要实现的线程池了，首先看该类的一些属性：

public class MyConnectionPool implements ConnectionPool {

    //初始化连接数量
    int initSize;
    //最大连接数量
    int maxSize;
    //最大空闲连接数量
    int idleCount;
    //最大等待时间
    long waitTime;
    //活跃连接数
    AtomicInteger activeSize;
    //空闲队列
    BlockingQueue<Connection> idle;
    //已使用队列
    BlockingQueue<Connection> busy;

这里定义了两个队列，一个存放空闲连接，一个存放正在使用的连接。活跃连接数就是连接池中未关闭的连接的总数，也就是两个队列的连接总数。

取出连接和回收连接方法模型图：

在这里插入图片描述

构造器

通过构造方法完成初始化：

	public MyConnectionPool(int initSize, int maxSize, int idleCount, long waitTime) {
        init(initSize ,maxSize,idleCount,waitTime);
    }

    public MyConnectionPool() {}

    @Override
    public void init(int initSize, int maxSize, int idleCount, long waitTime) {
        this.initSize = initSize;
        this.maxSize = maxSize;
        this.idleCount = idleCount;
        this.waitTime = waitTime;
        this.activeSize = new AtomicInteger();
        this.idle = new LinkedBlockingQueue<Connection>();
        this.busy = new LinkedBlockingQueue<Connection>();
        //初始化连接
        initConnection(initSize);
    }

    private void initConnection(int initSize) {
        for (int i = 0; i <initSize ; i++) {
            if (activeSize.get()<maxSize){//两重判断是为了保证线程安全
                if (activeSize.incrementAndGet()<=maxSize){
                    //创建连接
                    Connection conn = MysqlConnectionUtils.getConnection();
                    //加入空闲队列
                    idle.offer(conn);
                }else{
                    activeSize.decrementAndGet();
                }
            }
        }
    }

构造线程池时，输入四个初始化参数，分别是初始化连接数、最大连接数、最大空闲连接数和超时时间。在构造方法中初始化两个核心队列，使用LinkedBlockingQueue有序阻塞队列。并在构造方法中创建初始化连接数数量的连接，放入空闲队列，注意每成功创建一个连接，活跃连接数activeSize加1。

这里activeSize使用原子类AtomicInteger，是考虑多线程的情况下线程安全问题，防止创建的线程数超出。

初始化方法两重if判断中进行原子操作，可形成锁，保证线程安全。

接下来实现从连接池中获取连接的方法：

获取连接方法：getConnection()
    @Override
    public Connection getConnection() throws TimeoutException {
        long startTime = System.currentTimeMillis();
        //1.从空闲队列里获取,return
        Connection conn = idle.poll();
        if (conn != null) {
            busy.offer(conn);
            System.out.println("["+Thread.currentThread().getName()+"]"+" ************从空闲队列获取连接************");
            return conn;
        }
        //2.空闲队列没有连接了，并且活跃连接数量不超过最大连接数量,创建一个新的连接return
        if (activeSize.get()<maxSize){//两重判断是为了保证线程安全
            if (activeSize.incrementAndGet()<=maxSize){
                conn = MysqlConnectionUtils.getConnection();
                System.out.println("["+Thread.currentThread().getName()+"]"+" ************创建一个新的连接************");
                busy.offer(conn);
                return conn;
            }else {
                activeSize.decrementAndGet();
            }
        }
        //3.连接全部正在使用，并且活跃连接数超过最大连接数量，则等待正在使用的连接被回收到空闲队列。
        //waitTime代表getConnection()方法的等待时间，poll方法阻塞时间其中一部分
        long timeout = waitTime - (System.currentTimeMillis()-startTime);
        try {
            //阻塞方法，等待从idle队列获取连接
            conn = idle.poll(timeout, TimeUnit.MILLISECONDS);
            if (conn == null) {
                throw new TimeoutException("["+Thread.currentThread().getName()+"]"+" ************获取连接超时，等待时间为"+timeout+"ms************");
            }
            busy.offer(conn);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return conn;
    }

以上代码核心就是两个队列弹出元素和加入元素的过程。然后插入了一些打印信息，方便测试的时候查看。

获取连接实际上有三种可能的方式以及一种超时抛异常的情况：

  • 空闲队列中有可用连接，直接从空闲队列弹出
  • 空闲队列没有连接了，并且活跃连接数没有超过配置的最大连接数，此时自己创建连接给到调用者，注意每成功创建一个连接，活跃连接数activeSize加1。（从这里可以看出，如果最大空闲连接数设置得过小，最大连接数远大于最大空闲连接数的话，线程池会大量创建连接，性能就会比较差。）
  • 空闲队列没有连接，并且活跃连接数达到配置的最大连接数，此时不能在创建连接，只能阻塞等待，当超时时间内有连接被回收进空闲队列，阻塞结束，获得连接。
  • 当达到超时时间没有连接被回收，抛出超时异常。（这里超时时间的配置应当根据多数线程占用连接的时间决定）

然后看另一个关键的方法，回收方法：

回收方法：recycle()
    @Override
    public void recycle(Connection conn) {
        if (conn == null) { return;}
        //回收连接，就是将连接从使用队列移动到空闲队列
        if (busy.remove(conn)){//第一步，移除
            //如果实际的空闲连接数量大于用户指定的最大空闲连接数量，则连接多余了，关闭连接
            if (idle.size()>=idleCount){
                MysqlConnectionUtils.closeConnection(conn);
                //关闭连接，则活跃连接减一
                activeSize.decrementAndGet();
                System.out.println("["+Thread.currentThread().getName()+"]"+" ++++空闲连接数量太多，关闭连接++++");
                return;
            }
            if (!idle.offer(conn)){//第二步，放入，如果放入空闲队列失败，关闭连接
                MysqlConnectionUtils.closeConnection(conn);
                activeSize.decrementAndGet();
            }
            System.out.println("["+Thread.currentThread().getName()+"]"+" ++++回收连接成功++++");
        }else{//从busy队列移除失败，可能因为该连接不在busy队列中
            MysqlConnectionUtils.closeConnection(conn);
            activeSize.decrementAndGet();
            System.out.println("["+Thread.currentThread().getName()+"]"+" ++++未知连接，直接关闭，不予回收++++");
        }
    }

回收方法实际就是两步，

  • 将指定的连接从busy队列中弹出，如果该连接不是busy队列中的连接，也就是弹出失败，就直接关闭它。
  • 检查空闲队列内的连接数，如果达到配置的最大空闲连接数，则直接关闭连接。如果没有达到，就将该连接放入空闲队列。

注意每关闭一个连接，活跃连接数activeSize减1。

连接池销毁方法：destroy()
	@Override
    public void destory() {
        while (busy.size()!=0){
            recycle(busy.poll());
        }
        while(idle.size()!=0){
            MysqlConnectionUtils.closeConnection(idle.poll());
            activeSize.decrementAndGet();
        }
    }

将连接全部回收，然后关闭所有控线连接。

至此，一个简单的数据库连接池实现完毕。核心方法就是获取连接方法和回收方法。下面通过设置不同的参数来测试一下功能好不好使，以及分析这些参数应当根据那些因素来配置。

三、测试连接池

测试类代码如下：

public class TestMain {
    private static int threadNum = 50;

    public static void main(String[] args) {
        String sql = "select email from user where id = 5";
        CountDownLatch cdl = new CountDownLatch(1);
        ConnectionPool pool = new MyConnectionPool(10,20,15,20000L);
        for (int i = 0; i <threadNum ; i++) {
            new Thread(() ->{
                Connection conn = null;
                try {
                    cdl.await();  //阻塞在这，等待所有线程准备好，发令枪响，一起执行
                    conn = pool.getConnection();
                    PreparedStatement statement = conn.prepareStatement(sql);
                    ResultSet result = statement.executeQuery();
                    while (result.next()){
                        String email = result.getString(1);
                        System.out.println("【email】:"+email);
                    }
                    //Thread.currentThread().sleep(1000L*new Random().nextInt(5));//模拟线程占用连接的时间
                } catch (TimeoutException | InterruptedException | SQLException e) {
                    e.printStackTrace();
                } finally {
                    pool.recycle(conn);
                }
            }).start();

        }
        cdl.countDown();  //发令枪，唤醒所有线程
        sleep(3000);//等待所有线程执行完毕
        System.out.println("已建立连接数："+((MyConnectionPool) pool).activeSize.get()+
                "，空闲连接数："+((MyConnectionPool) pool).idle.size()+
                "，正在使用连接数："+((MyConnectionPool) pool).busy.size());
        pool.destory();
        System.out.println("detroy MyConnectionPool!!");
        System.out.println("已建立连接数："+((MyConnectionPool) pool).activeSize.get()+
                "，空闲连接数："+((MyConnectionPool) pool).idle.size()+
                "，正在使用连接数："+((MyConnectionPool) pool).busy.size());
    }

    public static void sleep(long time){
        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

首先设置50个线程并发访问连接池，初始化连接数10、最大连接数20、最大空闲连接数15、超时时间20秒，

ConnectionPool pool = new MyConnectionPool(10,20,15,20000L);

测试结果：

[Thread-1] 从空闲队列获取连接
…
[Thread-17] 创建一个新的连接
…

【email】:[email protected]

[Thread-20] ++++回收连接成功++++
…
[Thread-23] ++++空闲连接数量太多，关闭连接++++
…
已建立连接数：15，空闲连接数：15，正在使用连接数：0

detroy MyConnectionPool!!
已建立连接数：0，空闲连接数：0，正在使用连接数：0

由于篇幅原因，打印信息省略一部分。

本次测试得到以下信息：

  • 由于设置的超时时间是20秒，远大于各线程占用时间，所以没有出现超时异常的情况。
  • 初始化了10个连接，“创建一个连接”输出了10行，“空闲连接数量太多，关闭连接”输出了5行，所有线程执行完毕后，已建立连接数：15，空闲连接数：15，正在使用连接数：0。说明没有连接泄露。
  • 最大空闲连接数实际就是并发量够大时的连接的缓存容量，

更改参数再次测试，设置超时时间为3秒，模拟线程随机1到5秒的占用连接时间，主线程等待10秒：

ConnectionPool pool = new MyConnectionPool(10,20,15,3000L);

Thread.currentThread().sleep(1000L*new Random().nextInt(5));//模拟线程占用连接的时间

sleep(10000);

[Thread-1] 从空闲队列获取连接
…
[Thread-17] 创建一个新的连接
…

【email】:[email protected]

java.util.concurrent.TimeoutException: [Thread-38] 获取连接超时，等待时间为3000ms
at com.youzi.test.concurrent.connPool.MyConnectionPool.getConnection(MyConnectionPool.java:100)
at com.youzi.test.concurrent.connPool.TestMain.lambda$main$0(TestMain.java:23)
at java.lang.Thread.run(Thread.java:745)

[Thread-20] ++++回收连接成功++++
…
[Thread-23] ++++空闲连接数量太多，关闭连接++++
…
已建立连接数：15，空闲连接数：15，正在使用连接数：0

detroy MyConnectionPool!!
已建立连接数：0，空闲连接数：0，正在使用连接数：0

可以看到由于线程占用连接时间为随机1到5秒，而设置超时时间是3秒，在被占用连接数量达到最大连接数20时，某线程3秒内没有获取到连接，就会抛出超时异常。不影响其他线程。

线程池连接数量始终符合根据配置该有的数量。没有超出配置，也没有连接泄露。

手写连接池测试完毕。

yozzs
发布了43 篇原创文章 · 获赞 17 · 访问量 3万+
私信 关注

猜你喜欢

转载自blog.csdn.net/weixin_41172473/article/details/94387052
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022