数据库连接池的实现_摸鱼写代码的博客-爱代码爱编程
数据库连接池的实现
文章目录
1、数据库连接池
1.1、池化技术
池化技术能够减少资源对象的创建次数,提高程序的响应性能,特别是在高并发场景。使用池化技术缓存的资源对象有如下共同特点:
- 对象创建时间长
- 对象创建需要大量资源
- 对象创建后可被重复使用
像常见的线程池、内存池、连接池、对象池都具有以上的共同特点。
1.2、数据库连接池
数据库连接池(Connection pooling) :是程序启动时建立足够的数据库连接,并将这些连接组成一个连接池,由程序动态地对池中的连接进行申请,使用,释放。
1.2.1、为什么使用数据库连接池
- 资源复用:避免了连接的频繁创建和释放引起的性能开销,增加了系统运行环境的平稳性(减少内存碎片、减少临时线程的数量)
- 高响应速度:连接池初始化后,业务请求可以直接复用现有可用连接,避免了连接创建和释放的开销,缩减了系统的整体响应时间。
- 统一的连接管理,避免数据库连接泄漏:可根据预先的连接占用超时设定,强制收回被占用连接。从而避免了常规数据库连接操作中可能出现的资源泄露。
不使用数据库连接池,则对于每条 sql 语句,都要执行下面流程
采用这样的方式,带来的问题有:
- 带宽利用率低
- QPS(每秒处理事务数)较低
- 频繁创建连接和关闭连接,导致临时对象较多,带来更多的内存碎片
- 关闭连接后,会出现大量
TIME_WAIT
状态
使用数据库连接池,初次访问,建立连接。 之后的访问复用之前的连接,直接执行 sql 语句。
优点
- 降低了网络开销
- 连接复用,有效减少连接数。
- 提升性能,避免频繁的连接创建和释放
- 没有TIME_WAIT状态的问题
1.2.2、长连接与连接池的区别
- 长连接是特性,由驱动来保持连接句柄的打开,复用连接,减少数据库的连接开销。
- 连接池是应用服务器的组件,连接池内的连接,其实就是长连接。
1.2.3、数据库连接池的运行机制
- 从连接池获取或创建可用连接
- 使用完毕之后,把连接归还给连接池
- 在系统关闭前,断开所有连接并释放连接占用的系统资源
对于每个任务,核心是:获取连接 -> 操作数据库 -> 归还连接
task() {
conn = 从连接池获取
操作数据库
归还 conn
}
1.2.4、连接池和线程池的区别
- 线程池:主动操作,主动获取任务并执行
- 连接池:被动操作,连接对象被任务获取,执行完任务后归还,内存池同理
连接池和线程池设置数量关系:一般地,线程池线程数量和连接池连接对象数量一致。
2、连接池的设计
连接池设计思路:
- 连接到数据库,涉及到数据库ip、端口、用户名、密码、数据库名字等
- 连接的操作:每个连接对象都是长连接,相互独立
- 配置最小连接数(一般设置为线程数)和最大连接数
- 一个队列管理池内的连接,比如使用
list
,set
- 获取连接对象
- 归还连接对象
- 连接池的名字
2.1、连接池的设计逻辑
构造函数
初始化
构造与初始化分离,因为构造函数无返回值,可能失败的操作需要抛出异常,外部捕获。
请求获取连接
先判断有没有空闲连接
-
有空闲连接,获取连接返回
-
没有空闲连接,是否能创建新的连接
-
能够创建新的连接,创建新的连接,获取连接返回
-
不能创建新的连接,等待的逻辑,直到有空闲的连接可用,或连接池退出无法获取
-
归还连接
析构连接池
2.2、mysql 连接池
构造函数
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; // mysql ip地址
m_db_server_port = db_server_port; // mysql 端口
m_username = username; // mysql 用户名
m_password = password; // mysql 密码
m_db_name = db_name; // mysql 数据库名称
m_db_max_conn_cnt = max_conn_cnt; // 最大连接数
m_db_cur_conn_cnt = MIN_DB_CONN_CNT; // 最小连接数量
}
初始化
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 *CDBPool::GetDBConn(const int timeout_ms) {
// 加锁
std::unique_lock<std::mutex> lock(m_mutex);
// 是否关闭连接池,关闭则不能获取连接
if(m_abort_request) {
return NULL;
}
// 连接池是否存在可用的空闲连接?
// 1、没有空闲连接
if (m_free_list.empty()) {
// 是否可以创建新的连接,即当前连接数是否达到最大连接数?
// 1.1、不能创建新的连接,当前连接数已经达到最大连接数
if (m_db_cur_conn_cnt >= m_db_max_conn_cnt) {
// 等待的逻辑,是否需要超时等待
// 1.1.1、死等, wait,直到有空闲连接可用,或连接池要释放
if(timeout_ms <= 0) {
// 1. m_free_list不为空,等到了空闲连接,
// 2. 或者请求释放连接池(否则无法退出)
m_cond_var.wait(lock, [this] {
return (!m_free_list.empty()) | m_abort_request;
});
}
// 1.1.2、超时等待, wait for
// 直到有空闲连接可用,或超时退出,或连接池要释放
else {
// 1.m_free_list不为空,等到了空闲连接
// 2.超时退出
// 3. m_abort_request被置为true,要释放整个连接池
m_cond_var.wait_for(lock, std::chrono::milliseconds(timeout_ms), [this] {
return (!m_free_list.empty()) | m_abort_request;
});
// 如果没有等到空闲连接
if(m_free_list.empty()) {
return NULL;
}
}
// 若连接池要释放,则不能获取资源
if(m_abort_request) {
return NULL;
}
}
// 1.2、可以创建新的连接,当前连接数未达到最大连接数
else {
//建立新的连接
CDBConn *pDBConn = new CDBConn(this);
int ret = pDBConn->Init();
if (ret) {
delete pDBConn;
return NULL;
}
else {
m_free_list.push_back(pDBConn);
m_db_cur_conn_cnt++;
}
}
}
// 2、存在空闲连接
// 获取连接
CDBConn *pConn = m_free_list.front();
// 从空闲队列删除
m_free_list.pop_front();
// 加入到已经被请求的连接
m_used_list.push_back(pConn);
return pConn;
}
归还连接
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();
}
}
析构连接池
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();
}
常见问题
问题1:too many connections
首先登录mysql终端,查看最大连接数。
show variables like '%max_connection%';
临时修改默认连接数
set GLOBAL max_connections=1000;
问题2:Your password does not satisfy the current policy requirements
重新设置密码表的级别
SHOW VARIABLES LIKE 'validate_password%';
set global validate_password_length=6;
set global validate_password_policy=0;
问题3:Access denied for user ‘root’@‘localhost’,
没有设置对应用户的权限
# 查找 mysql.user 中的用户
SELECT `user`,`host`,`authentication_string`,`plugin` FROM mysql.user;
# 创建远程连接的用户
CREATE USER 'root'@'%' IDENTIFIED BY '123456';
GRANT ALL ON maindataplus.* TO 'root'@'%';
flush privileges;
# 修改本地连接用户的密码
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '123456';
flush privileges;
2.3、redis 连接池
构造函数
CachePool::CachePool(const char *pool_name, const char *server_ip, int server_port, int db_index,
const char *password, int max_conn_cnt)
{
m_pool_name = pool_name;
m_server_ip = server_ip;
m_server_port = server_port;
m_db_index = db_index;
m_password = password;
m_max_conn_cnt = max_conn_cnt;
m_cur_conn_cnt = MIN_CACHE_CONN_CNT;
}
初始化
int CachePool::Init()
{
// 创建最小的连接数量
for (int i = 0; i < m_cur_conn_cnt; i++)
{
// 新建连接
CacheConn *pConn = new CacheConn(m_server_ip.c_str(), m_server_port,
m_db_index, m_password.c_str(), m_pool_name.c_str());
// 初始化连接
if (pConn->Init())
{
delete pConn;
return 1;
}
// 新建立的连接放入容器管理
m_free_list.push_back(pConn);
}
return 0;
}
请求获取连接
CacheConn *CachePool::GetCacheConn() {
m_free_notify.Lock();
// 连接池是否存在可用的空闲连接
// 1、没有空闲连接
while (m_free_list.empty()) {
// 能否创建新的连接,当前连接数量是否已经达到最大连接数量
// 1.1、不能创建新的连接,当前连接数量已经达到最大连接数量
if (m_cur_conn_cnt >= m_max_conn_cnt) {
// 等待空闲连接可用
m_free_notify.Wait();
}
// 1.2、可以创建新的连接,当前连接数未达到最大连接数
else {
// 创建新的连接
CacheConn *p_cache_conn = new CacheConn(m_server_ip.c_str(), m_server_port,
m_db_index, m_password.c_str(), m_pool_name.c_str());
int ret = p_cache_conn->Init();
if (ret) {
delete p_cache_conn;
m_free_notify.Unlock();
return NULL;
}
else {
m_free_list.push_back(p_cache_conn);
m_cur_conn_cnt++;
}
}
}
// 2、存在空闲连接
// 获取空闲连接
CacheConn *pConn = m_free_list.front();
// 从空闲队列中删除
m_free_list.pop_front();
m_free_notify.Unlock();
return pConn;
}
归还连接
void CachePool::RelCacheConn(CacheConn *p_cache_conn) {
m_free_notify.Lock();
list<CacheConn *>::iterator it = m_free_list.begin();
// 检测该连接是否已经归还,避免重复归还
for (; it != m_free_list.end(); it++) {
if (*it == p_cache_conn) {
break;
}
}
// 还没有归还,插入空闲队列并通知取队列
if (it == m_free_list.end()) {
m_free_list.push_back(p_cache_conn);
}
m_free_notify.Signal();
m_free_notify.Unlock();
}
析构连接池
CachePool::~CachePool() {
m_free_notify.Lock();
for (list<CacheConn *>::iterator it = m_free_list.begin(); it != m_free_list.end(); it++) {
CacheConn *pConn = *it;
delete pConn;
}
m_free_list.clear();
m_cur_conn_cnt = 0;
m_free_notify.Unlock();
}
3、连接池连接数量设置
经验公式:连接数 = ((cpu核心数 * 2) + 有效磁盘数)
# 查看CPU信息(型号)
cat /proc/cpuinfo | grep name | cut -f2 -d: | uniq -c
# 查看物理CPU个数
cat /proc/cpuinfo| grep "physical id"| sort| uniq| wc -l
# 查看每个物理cpu核数
cat /proc/cpuinfo| grep "cpu cores"| uniq
# 查看逻辑cpu的个数
cat /proc/cpuinfo| grep "processor"| wc -l
io 密集型任务:设置 cpu 利用率倒数个数的线程数和连接数