首发于 c/c++linux

mysql连接池的实现

清风

前言

本文介绍mysql连接池的实现。我记得go提供的原生sql包里面就是用的连接池，重在理解连接池的概念即可。

池化技术

池化技术能够减少资源对象的创建次数，提高程序的响应性能，特别是在高并发的场景下这种提升会更加明显，所以池化技术相当于一层缓冲。使用池化技术缓存的资源对象有如下共同特点：

像线程池，内存池，请求池，对象池，连接池都具备以上的共同特点。

数据库连接池

什么是数据库连接池

数据库连接池是程序启动时建立足够数量的数据库连接，并将这些连接统一管理起来组成一个连接池，程序动态的从池中取连接与归还连接。

创建数据库连接相对来说是比较耗时的，不仅有三次握手，还有mysql的三次认证过程。所以在程序启动时就创建多个连接统一管理，可以提高程序的响应性能。

为什么使用数据库连接池

不使用连接池的执行过程

可以看到，为了执行一条sql，要经历五个步骤：

1. TCP建立连接的三次握手
2. MySQL认证的三次握手
3. 真正的SQL执行
4. MySQL的关闭
5. TCP的四次握手关闭

不使用连接池的优点是代码实现起来比较简单，但是不使用连接池的缺点有很多:

网络IO较多
带宽利用率低
QPS较低
应用频繁低创建连接和关闭连接，导致临时对象较多，带来更多的内存碎片
在关闭连接后，会出现大量TIME_WAIT 的TCP状态（在2个MSL之后关闭）

使用连接池的执行过程

在连接池初始化的时候，会按照需求建立N个连接，但是之后的访问，都会从池里面取，复用初始化时创建的连接，直接执行sql语句。

使用连接池的优点：

1. 降低了网络开销
2. 连接复用，有效减少连接数。
3. 提升性能，避免频繁的新建连接。新建连接的开销比较大
4. 没有TIME_WAIT状态的问题

但是缺点也很明显，就是代码实现较为复杂。

数据库连接池运行机制

连接池和线程池的关系

连接池和线程池的区别: - 线程池：主动去调用任务，当任务队列不为空的时候从任务队列中取任务（比如去银行办理业务，窗口柜员是线程，多个窗口组成了线程池，柜员从排号队列叫号执行。） - 连接池：被动被任务使用，当某任务需要操作数据库时，只要从连接池中取出一个连接对象，当任务使用完该连接对象后，将该连接对象放回到连接池中。如果连接池中没有连接对象可以用，那么该任务就必须等待。（比如去银行用笔填单，笔是连接对象，我们要用笔的时候去取，用完了还回去。）

连接池和线程池设置数量的关系：

线程池设计与代码实现

线程池设计要点

使用连接池需要预先建立数据库连接。线程池设计思路：

1. 连接到数据库，涉及到数据库ip、端口、用户名、密码、数据库名字等；
    a. 连接的操作，每个连接对象都是独立的连接通道，它们是独立的
    b. 配置最小连接数和最大连接数
2. 需要一个队列管理他的连接，比如使用list；
3. 获取连接对象：
4. 归还连接对象；
5. 连接池的名字

构造函数

CDBPool *pDBPool = new CDBPool(db_pool_name, db_host, db_port,db_username, db_password, db_dbname, db_maxconncnt);

CDBPool::CDBPool(const char *pool_name, const char *db_server_ip, uint16_t db_server_port,
                 const char *username, const char *password, const char *db_name, int max_conn_cnt) {
    m_pool_name = pool_name;
    m_db_server_ip = db_server_ip;
    m_db_server_port = db_server_port;
    m_username = username;
    m_password = password;
    m_db_name = db_name;
    m_db_max_conn_cnt = max_conn_cnt;    //
    m_db_cur_conn_cnt = MIN_DB_CONN_CNT; // 最小连接数量
}

初始化

if (pDBPool->Init()) {
    printf("init db instance failed: %s", db_pool_name);
    return -1;
}
int CDBPool::Init() {
    // 创建固定最小的连接数量
    for (int i = 0; i < m_db_cur_conn_cnt; i++) {
        CDBConn *pDBConn = new CDBConn(this);
        int ret = pDBConn->Init();
        if (ret) {
            delete pDBConn;
            return ret;
        }

        m_free_list.push_back(pDBConn);
    }
    return 0;
}

获取连接池内的连接

CDBConn *pDBConn = pDBPool->GetDBConn(); // 获取连接

CDBConn *CDBPool::GetDBConn(const int timeout_ms) {
    std::unique_lock<std::mutex> lock(m_mutex);
    if (m_abort_request) {
        log_warn("have aboort\n");
        return NULL;
    }

    if (m_free_list.empty()) {       // 当没有连接可以用时
        // 第一步先检测 当前连接数量是否达到最大的连接数量
        if (m_db_cur_conn_cnt >= m_db_max_conn_cnt) {
            // 如果已经到达了，看看是否需要超时等待
            if (timeout_ms <= 0)        // 死等，直到有连接可以用 或者 连接池要退出
            {
                log_info("wait ms:%d\n", timeout_ms);
                m_cond_var.wait(lock, [this] {
                    // log_info("wait:%d, size:%d\n", wait_cout++, m_free_list.size());
                    // 当前连接数量小于最大连接数量 或者请求释放连接池时退出
                    return (!m_free_list.empty()) | m_abort_request;
                });
            }
            else {
                // return如果返回 false，继续wait(或者超时),  如果返回true退出wait
                // 1.m_free_list不为空
                // 2.超时退出
                // 3. m_abort_request被置为true，要释放整个连接池
                m_cond_var.wait_for(lock, std::chrono::milliseconds(timeout_ms), [this] {
                    // log_info("wait_for:%d, size:%d\n", wait_cout++, m_free_list.size());
                    return (!m_free_list.empty()) | m_abort_request;
                });
                // 带超时功能时还要判断是否为空
                if (m_free_list.empty())    // 如果连接池还是没有空闲则退出
                {
                    return NULL;
                }
            }

            if (m_abort_request) {
                log_warn("have aboort\n");
                return NULL;
            }
        }
        else // 还没有到最大连接则创建连接
        {
            CDBConn *pDBConn = new CDBConn(this);    //新建连接
            int ret = pDBConn->Init();
            if (ret) {
                log_error("Init DBConnecton failed\n\n");
                delete pDBConn;
                return NULL;
            }
            else {
                m_free_list.push_back(pDBConn);
                m_db_cur_conn_cnt++;
                // log_info("new db connection: %s, conn_cnt: %d\n", m_pool_name.c_str(), m_db_cur_conn_cnt);
            }
        }
    }

    CDBConn *pConn = m_free_list.front();    // 获取连接
    m_free_list.pop_front();    // STL 吐出连接，从空闲队列删除
    m_used_list.push_back(pConn);        //
    return pConn;
}

归还连接至连接池

pDBPool->RelDBConn(pDBConn); // 一定要归还

void CDBPool::RelDBConn(CDBConn *pConn) {
    std::lock_guard<std::mutex> lock(m_mutex);
    list<CDBConn *>::iterator it = m_free_list.begin();
    for (; it != m_free_list.end(); it++) { // 避免重复归还
        if (*it == pConn) {
            break;
        }
    }

    if (it == m_free_list.end()) {
        m_used_list.remove(pConn);
        m_free_list.push_back(pConn);
        m_cond_var.notify_one();        // 通知取队列
    }
    else {
        log_error("RelDBConn failed\n");
    }
}

析构函数

// 释放连接池
CDBPool::~CDBPool() {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_abort_request = true;
    m_cond_var.notify_all();        // 通知所有在等待的

    for (list<CDBConn *>::iterator it = m_free_list.begin(); it != m_free_list.end(); it++) {
        CDBConn *pConn = *it;
        delete pConn;
    }

    m_free_list.clear();
}

连接池名的作用

给每个池分配不同的名称，那么就可以用多个连接池实现不同的业务。

mysql连接重连机制

设置启用（当发现连接断开时的）自动重连

my_bool reconnect = true;
mysql_options(m_mysql, MYSQL_OPT_RECONNECT, &reconnect); // 配合mysql_ping实现自动重连

检测连接是否正常

int STDCALL mysql_ping(MYSQL *mysql);

编辑于 2022-08-16 11:12

MySQL

C / C++

连接池